use of uk.ac.sussex.gdsc.smlm.model.UniformDistribution in project GDSC-SMLM by aherbert.
the class CreateData method createUniformDistribution.
/**
* Create distribution within an XY border.
*
* @param border the border
* @return the uniform distribution
*/
private UniformDistribution createUniformDistribution(double border) {
final double depth = (settings.getFixedDepth()) ? settings.getDepth() / settings.getPixelPitch() : settings.getDepth() / (2 * settings.getPixelPitch());
// Ensure the focal plane is in the middle of the zDepth
final double[] max = new double[] { settings.getSize() / 2.0 - border, settings.getSize() / 2.0 - border, depth };
final double[] min = new double[3];
for (int i = 0; i < 3; i++) {
min[i] = -max[i];
}
if (settings.getFixedDepth()) {
min[2] = max[2];
}
// Try using different distributions:
if (settings.getDistribution().equals(DISTRIBUTION[UNIFORM_HALTON])) {
return new UniformDistribution(min, max, createRandomGenerator().nextInt());
}
if (settings.getDistribution().equals(DISTRIBUTION[UNIFORM_SOBOL])) {
final SobolSequenceGenerator rvg = new SobolSequenceGenerator(3);
rvg.skipTo(createRandomGenerator().nextInt());
return new UniformDistribution(min, max, rvg);
}
// Create a distribution using random generators for each dimension
return new UniformDistribution(min, max, this::createRandomGenerator);
}
use of uk.ac.sussex.gdsc.smlm.model.UniformDistribution in project GDSC-SMLM by aherbert.
the class BlinkEstimatorTest method estimateBlinking.
private TIntHashSet estimateBlinking(UniformRandomProvider rg, double blinkingRate, double ton, double toff, int particles, double fixedFraction, boolean timeAtLowerBound, boolean doAssert) {
Assumptions.assumeTrue(TestSettings.allow(TestComplexity.MAXIMUM));
final SpatialIllumination activationIllumination = new UniformIllumination(100);
int totalSteps = 100;
final double eAct = totalSteps * 0.3 * activationIllumination.getAveragePhotons();
final ImageModel imageModel = new ActivationEnergyImageModel(eAct, activationIllumination, ton, 0, toff, 0, blinkingRate, rg);
final double[] max = new double[] { 256, 256, 32 };
final double[] min = new double[3];
final SpatialDistribution distribution = new UniformDistribution(min, max, rg.nextInt());
final List<CompoundMoleculeModel> compounds = new ArrayList<>(1);
final CompoundMoleculeModel c = new CompoundMoleculeModel(1, 0, 0, 0, Arrays.asList(new MoleculeModel(0, 0, 0, 0)));
c.setDiffusionRate(diffusionRate);
c.setDiffusionType(DiffusionType.RANDOM_WALK);
compounds.add(c);
final List<CompoundMoleculeModel> molecules = imageModel.createMolecules(compounds, particles, distribution, false);
// Activate fluorophores
final List<? extends FluorophoreSequenceModel> fluorophores = imageModel.createFluorophores(molecules, totalSteps);
totalSteps = checkTotalSteps(totalSteps, fluorophores);
final List<LocalisationModel> localisations = imageModel.createImage(molecules, fixedFraction, totalSteps, photons, 0.5, false);
// // Remove localisations to simulate missed counts.
// List<LocalisationModel> newLocalisations = new
// ArrayList<LocalisationModel>(localisations.size());
// boolean[] id = new boolean[fluorophores.size() + 1];
// Statistics photonStats = new Statistics();
// for (LocalisationModel l : localisations)
// {
// photonStats.add(l.getIntensity());
// // Remove by intensity threshold and optionally at random.
// if (l.getIntensity() < minPhotons || rand.nextDouble() < pDelete)
// continue;
// newLocalisations.add(l);
// id[l.getId()] = true;
// }
// localisations = newLocalisations;
// logger.info("Photons = %f", photonStats.getMean());
//
// List<FluorophoreSequenceModel> newFluorophores = new
// ArrayList<FluorophoreSequenceModel>(fluorophores.size());
// for (FluorophoreSequenceModel f : fluorophores)
// {
// if (id[f.getId()])
// newFluorophores.add(f);
// }
// fluorophores = newFluorophores;
final MemoryPeakResults results = new MemoryPeakResults();
final CalibrationWriter calibration = new CalibrationWriter();
calibration.setNmPerPixel(pixelPitch);
calibration.setExposureTime(msPerFrame);
calibration.setCountPerPhoton(1);
results.setCalibration(calibration.getCalibration());
results.setPsf(PsfHelper.create(PSFType.ONE_AXIS_GAUSSIAN_2D));
final float b = 0;
float intensity;
final float z = 0;
for (final LocalisationModel l : localisations) {
// Remove by intensity threshold and optionally at random.
if (l.getIntensity() < minPhotons || rg.nextDouble() < probabilityDelete) {
continue;
}
final int frame = l.getTime();
intensity = (float) l.getIntensity();
final float x = (float) l.getX();
final float y = (float) l.getY();
final float[] params = Gaussian2DPeakResultHelper.createParams(b, intensity, x, y, z, psfWidth);
results.add(frame, 0, 0, 0, 0, 0, 0, params, null);
}
// Add random localisations
// Intensity doesn't matter at the moment for tracing
intensity = (float) photons;
for (int i = (int) (localisations.size() * probabilityAdd); i-- > 0; ) {
final int frame = 1 + rg.nextInt(totalSteps);
final float x = (float) (rg.nextDouble() * max[0]);
final float y = (float) (rg.nextDouble() * max[1]);
final float[] params = Gaussian2DPeakResultHelper.createParams(b, intensity, x, y, z, psfWidth);
results.add(frame, 0, 0, 0, 0, 0, 0, params, null);
}
// Get actual simulated stats ...
final Statistics statsNBlinks = new Statistics();
final Statistics statsTOn = new Statistics();
final Statistics statsTOff = new Statistics();
final Statistics statsSampledNBlinks = new Statistics();
final Statistics statsSampledTOn = new Statistics();
final StoredDataStatistics statsSampledTOff = new StoredDataStatistics();
for (final FluorophoreSequenceModel f : fluorophores) {
statsNBlinks.add(f.getNumberOfBlinks());
statsTOn.add(f.getOnTimes());
statsTOff.add(f.getOffTimes());
final int[] on = f.getSampledOnTimes();
statsSampledNBlinks.add(on.length);
statsSampledTOn.add(on);
statsSampledTOff.add(f.getSampledOffTimes());
}
logger.info(FunctionUtils.getSupplier("N = %d (%d), N-blinks = %f, tOn = %f, tOff = %f, Fixed = %f", fluorophores.size(), localisations.size(), blinkingRate, ton, toff, fixedFraction));
logger.info(FunctionUtils.getSupplier("Actual N-blinks = %f (%f), tOn = %f (%f), tOff = %f (%f), 95%% = %f, max = %f", statsNBlinks.getMean(), statsSampledNBlinks.getMean(), statsTOn.getMean(), statsSampledTOn.getMean(), statsTOff.getMean(), statsSampledTOff.getMean(), statsSampledTOff.getStatistics().getPercentile(95), statsSampledTOff.getStatistics().getMax()));
logger.info("-=-=--=-");
final BlinkEstimator be = new BlinkEstimator();
be.setMaxDarkTime((int) (toff * 10));
be.setMsPerFrame(msPerFrame);
be.setRelativeDistance(false);
final double d = ImageModel.getRandomMoveDistance(diffusionRate);
be.setSearchDistance((fixedFraction < 1) ? Math.sqrt(2 * d * d) * 3 : 0);
be.setTimeAtLowerBound(timeAtLowerBound);
// Assertions.assertTrue("Max dark time must exceed the dark time of the data (otherwise no
// plateau)",
// be.maxDarkTime > statsSampledTOff.getStatistics().getMax());
final int nMolecules = fluorophores.size();
if (usePopulationStatistics) {
blinkingRate = statsNBlinks.getMean();
toff = statsTOff.getMean();
} else {
blinkingRate = statsSampledNBlinks.getMean();
toff = statsSampledTOff.getMean();
}
// See if any fitting regime gets a correct answer
final TIntHashSet ok = new TIntHashSet();
for (int numberOfFittedPoints = MIN_FITTED_POINTS; numberOfFittedPoints <= MAX_FITTED_POINTS; numberOfFittedPoints++) {
be.setNumberOfFittedPoints(numberOfFittedPoints);
be.computeBlinkingRate(results, true);
final double moleculesError = DoubleEquality.relativeError(nMolecules, be.getNMolecules());
final double blinksError = DoubleEquality.relativeError(blinkingRate, be.getNBlinks());
final double offError = DoubleEquality.relativeError(toff * msPerFrame, be.getTOff());
logger.info(FunctionUtils.getSupplier("Error %d: N = %f, blinks = %f, tOff = %f : %f", numberOfFittedPoints, moleculesError, blinksError, offError, (moleculesError + blinksError + offError) / 3));
if (moleculesError < relativeError && blinksError < relativeError && offError < relativeError) {
ok.add(numberOfFittedPoints);
logger.info("-=-=--=-");
logger.info(FunctionUtils.getSupplier("*** Correct at %d fitted points ***", numberOfFittedPoints));
if (doAssert) {
break;
}
}
// if (!be.isIncreaseNFittedPoints())
// break;
}
logger.info("-=-=--=-");
if (doAssert) {
Assertions.assertFalse(ok.isEmpty());
}
// relativeError);
return ok;
}
use of uk.ac.sussex.gdsc.smlm.model.UniformDistribution in project GDSC-SMLM by aherbert.
the class PcPalmMolecules method runSimulation.
private void runSimulation(boolean resultsAvailable) {
if (resultsAvailable && !showSimulationDialog()) {
return;
}
startLog();
log("Simulation parameters");
if (settings.blinkingDistribution == 3) {
log(" - Clusters = %d", settings.numberOfMolecules);
log(" - Simulation size = %s um", MathUtils.rounded(settings.simulationSize, 4));
log(" - Molecules/cluster = %s", MathUtils.rounded(settings.blinkingRate, 4));
log(" - Blinking distribution = %s", Settings.BLINKING_DISTRIBUTION[settings.blinkingDistribution]);
log(" - p-Value = %s", MathUtils.rounded(settings.pvalue, 4));
} else {
log(" - Molecules = %d", settings.numberOfMolecules);
log(" - Simulation size = %s um", MathUtils.rounded(settings.simulationSize, 4));
log(" - Blinking rate = %s", MathUtils.rounded(settings.blinkingRate, 4));
log(" - Blinking distribution = %s", Settings.BLINKING_DISTRIBUTION[settings.blinkingDistribution]);
}
log(" - Average precision = %s nm", MathUtils.rounded(settings.sigmaS, 4));
log(" - Clusters simulation = " + Settings.CLUSTER_SIMULATION[settings.clusterSimulation]);
if (settings.clusterSimulation > 0) {
log(" - Cluster number = %s +/- %s", MathUtils.rounded(settings.clusterNumber, 4), MathUtils.rounded(settings.clusterNumberStdDev, 4));
log(" - Cluster radius = %s nm", MathUtils.rounded(settings.clusterRadius, 4));
}
final double nmPerPixel = 100;
final double width = settings.simulationSize * 1000.0;
final UniformRandomProvider rng = UniformRandomProviders.create();
final UniformDistribution dist = new UniformDistribution(null, new double[] { width, width, 0 }, rng.nextInt());
final NormalizedGaussianSampler gauss = SamplerUtils.createNormalizedGaussianSampler(rng);
settings.molecules = new ArrayList<>(settings.numberOfMolecules);
// Create some dummy results since the calibration is required for later analysis
settings.results = new MemoryPeakResults(PsfHelper.create(PSFType.CUSTOM));
settings.results.setCalibration(CalibrationHelper.create(nmPerPixel, 1, 100));
settings.results.setSource(new NullSource("Molecule Simulation"));
settings.results.begin();
int count = 0;
// Generate a sequence of coordinates
final ArrayList<double[]> xyz = new ArrayList<>((int) (settings.numberOfMolecules * 1.1));
final Statistics statsRadius = new Statistics();
final Statistics statsSize = new Statistics();
final String maskTitle = TITLE + " Cluster Mask";
ByteProcessor bp = null;
double maskScale = 0;
if (settings.clusterSimulation > 0) {
// Simulate clusters.
// Note: In the Veatch et al. paper (Plos 1, e31457) correlation functions are built using
// circles with small radii of 4-8 Arbitrary Units (AU) or large radii of 10-30 AU. A
// fluctuations model is created at T = 1.075 Tc. It is not clear exactly how the particles
// are distributed.
// It may be that a mask is created first using the model. The particles are placed on the
// mask using a specified density. This simulation produces a figure to show either a damped
// cosine function (circles) or an exponential (fluctuations). The number of particles in
// each circle may be randomly determined just by density. The figure does not discuss the
// derivation of the cluster size statistic.
//
// If this plugin simulation is run with a uniform distribution and blinking rate of 1 then
// the damped cosine function is reproduced. The curve crosses g(r)=1 at a value equivalent
// to the average distance to the centre-of-mass of each drawn cluster, not the input cluster
// radius parameter (which is a hard upper limit on the distance to centre).
final int maskSize = settings.lowResolutionImageSize;
int[] mask = null;
// scale is in nm/pixel
maskScale = width / maskSize;
final ArrayList<double[]> clusterCentres = new ArrayList<>();
int totalSteps = 1 + (int) Math.ceil(settings.numberOfMolecules / settings.clusterNumber);
if (settings.clusterSimulation == 2 || settings.clusterSimulation == 3) {
// Clusters are non-overlapping circles
// Ensure the circles do not overlap by using an exclusion mask that accumulates
// out-of-bounds pixels by drawing the last cluster (plus some border) on an image. When no
// more pixels are available then stop generating molecules.
// This is done by cumulatively filling a mask and using the MaskDistribution to select
// a new point. This may be slow but it works.
// TODO - Allow clusters of different sizes...
mask = new int[maskSize * maskSize];
Arrays.fill(mask, 255);
MaskDistribution maskDistribution = new MaskDistribution(mask, maskSize, maskSize, 0, maskScale, maskScale, rng);
double[] centre;
IJ.showStatus("Computing clusters mask");
final int roiRadius = (int) Math.round((settings.clusterRadius * 2) / maskScale);
if (settings.clusterSimulation == 3) {
// Generate a mask of circles then sample from that.
// If we want to fill the mask completely then adjust the total steps to be the number of
// circles that can fit inside the mask.
totalSteps = (int) (maskSize * maskSize / (Math.PI * MathUtils.pow2(settings.clusterRadius / maskScale)));
}
while ((centre = maskDistribution.next()) != null && clusterCentres.size() < totalSteps) {
IJ.showProgress(clusterCentres.size(), totalSteps);
// The mask returns the coordinates with the centre of the image at 0,0
centre[0] += width / 2;
centre[1] += width / 2;
clusterCentres.add(centre);
// Fill in the mask around the centre to exclude any more circles that could overlap
final double cx = centre[0] / maskScale;
final double cy = centre[1] / maskScale;
fillMask(mask, maskSize, (int) cx, (int) cy, roiRadius, 0);
try {
maskDistribution = new MaskDistribution(mask, maskSize, maskSize, 0, maskScale, maskScale, rng);
} catch (final IllegalArgumentException ex) {
// This can happen when there are no more non-zero pixels
log("WARNING: No more room for clusters on the mask area (created %d of estimated %d)", clusterCentres.size(), totalSteps);
break;
}
}
ImageJUtils.finished();
} else {
// Pick centres randomly from the distribution
while (clusterCentres.size() < totalSteps) {
clusterCentres.add(dist.next());
}
}
final double scaledRadius = settings.clusterRadius / maskScale;
if (settings.showClusterMask || settings.clusterSimulation == 3) {
// Show the mask for the clusters
if (mask == null) {
mask = new int[maskSize * maskSize];
} else {
Arrays.fill(mask, 0);
}
final int roiRadius = (int) Math.round(scaledRadius);
for (final double[] c : clusterCentres) {
final double cx = c[0] / maskScale;
final double cy = c[1] / maskScale;
fillMask(mask, maskSize, (int) cx, (int) cy, roiRadius, 1);
}
if (settings.clusterSimulation == 3) {
// We have the mask. Now pick points at random from the mask.
final MaskDistribution maskDistribution = new MaskDistribution(mask, maskSize, maskSize, 0, maskScale, maskScale, rng);
// Allocate each molecule position to a parent circle so defining clusters.
final int[][] clusters = new int[clusterCentres.size()][];
final int[] clusterSize = new int[clusters.length];
for (int i = 0; i < settings.numberOfMolecules; i++) {
final double[] centre = maskDistribution.next();
// The mask returns the coordinates with the centre of the image at 0,0
centre[0] += width / 2;
centre[1] += width / 2;
xyz.add(centre);
// Output statistics on cluster size and number.
// TODO - Finding the closest cluster could be done better than an all-vs-all comparison
double max = distance2(centre, clusterCentres.get(0));
int cluster = 0;
for (int j = 1; j < clusterCentres.size(); j++) {
final double d2 = distance2(centre, clusterCentres.get(j));
if (d2 < max) {
max = d2;
cluster = j;
}
}
// Assign point i to cluster
centre[2] = cluster;
if (clusterSize[cluster] == 0) {
clusters[cluster] = new int[10];
}
if (clusters[cluster].length <= clusterSize[cluster]) {
clusters[cluster] = Arrays.copyOf(clusters[cluster], (int) (clusters[cluster].length * 1.5));
}
clusters[cluster][clusterSize[cluster]++] = i;
}
// Generate real cluster size statistics
for (int j = 0; j < clusterSize.length; j++) {
final int size = clusterSize[j];
if (size == 0) {
continue;
}
statsSize.add(size);
if (size == 1) {
statsRadius.add(0);
continue;
}
// Find centre of cluster and add the distance to each point
final double[] com = new double[2];
for (int n = 0; n < size; n++) {
final double[] xy = xyz.get(clusters[j][n]);
for (int k = 0; k < 2; k++) {
com[k] += xy[k];
}
}
for (int k = 0; k < 2; k++) {
com[k] /= size;
}
for (int n = 0; n < size; n++) {
final double dx = xyz.get(clusters[j][n])[0] - com[0];
final double dy = xyz.get(clusters[j][n])[1] - com[1];
statsRadius.add(Math.sqrt(dx * dx + dy * dy));
}
}
}
if (settings.showClusterMask) {
bp = new ByteProcessor(maskSize, maskSize);
for (int i = 0; i < mask.length; i++) {
if (mask[i] != 0) {
bp.set(i, 128);
}
}
ImageJUtils.display(maskTitle, bp);
}
}
// Use the simulated cluster centres to create clusters of the desired size
if (settings.clusterSimulation == 1 || settings.clusterSimulation == 2) {
for (final double[] clusterCentre : clusterCentres) {
final int clusterN = (int) Math.round((settings.clusterNumberStdDev > 0) ? settings.clusterNumber + gauss.sample() * settings.clusterNumberStdDev : settings.clusterNumber);
if (clusterN < 1) {
continue;
}
if (clusterN == 1) {
// No need for a cluster around a point
xyz.add(clusterCentre);
statsRadius.add(0);
statsSize.add(1);
} else {
// Generate N random points within a circle of the chosen cluster radius.
// Locate the centre-of-mass and the average distance to the centre.
final double[] com = new double[3];
int size = 0;
while (size < clusterN) {
// Generate a random point within a circle uniformly
// http://stackoverflow.com/questions/5837572/generate-a-random-point-within-a-circle-uniformly
final double t = 2.0 * Math.PI * rng.nextDouble();
final double u = rng.nextDouble() + rng.nextDouble();
final double r = settings.clusterRadius * ((u > 1) ? 2 - u : u);
final double x = r * Math.cos(t);
final double y = r * Math.sin(t);
final double[] xy = new double[] { clusterCentre[0] + x, clusterCentre[1] + y };
xyz.add(xy);
for (int k = 0; k < 2; k++) {
com[k] += xy[k];
}
size++;
}
// Add the distance of the points from the centre of the cluster.
// Note this does not account for the movement due to precision.
statsSize.add(size);
if (size == 1) {
statsRadius.add(0);
} else {
for (int k = 0; k < 2; k++) {
com[k] /= size;
}
while (size > 0) {
final double dx = xyz.get(xyz.size() - size)[0] - com[0];
final double dy = xyz.get(xyz.size() - size)[1] - com[1];
statsRadius.add(Math.sqrt(dx * dx + dy * dy));
size--;
}
}
}
}
}
} else {
// Random distribution
for (int i = 0; i < settings.numberOfMolecules; i++) {
xyz.add(dist.next());
}
}
// The Gaussian sigma should be applied so the overall distance from the centre
// ( sqrt(x^2+y^2) ) has a standard deviation of sigmaS?
final double sigma1D = settings.sigmaS / Math.sqrt(2);
// Show optional histograms
StoredDataStatistics intraDistances = null;
StoredData blinks = null;
if (settings.showHistograms) {
final int capacity = (int) (xyz.size() * settings.blinkingRate);
intraDistances = new StoredDataStatistics(capacity);
blinks = new StoredData(capacity);
}
final Statistics statsSigma = new Statistics();
for (int i = 0; i < xyz.size(); i++) {
int occurrences = getBlinks(rng, settings.blinkingRate);
if (blinks != null) {
blinks.add(occurrences);
}
final int size = settings.molecules.size();
// Get coordinates in nm
final double[] moleculeXyz = xyz.get(i);
if (bp != null && occurrences > 0) {
bp.putPixel((int) Math.round(moleculeXyz[0] / maskScale), (int) Math.round(moleculeXyz[1] / maskScale), 255);
}
while (occurrences-- > 0) {
final double[] localisationXy = Arrays.copyOf(moleculeXyz, 2);
// Add random precision
if (sigma1D > 0) {
final double dx = gauss.sample() * sigma1D;
final double dy = gauss.sample() * sigma1D;
localisationXy[0] += dx;
localisationXy[1] += dy;
if (!dist.isWithinXy(localisationXy)) {
continue;
}
// Calculate mean-squared displacement
statsSigma.add(dx * dx + dy * dy);
}
final double x = localisationXy[0];
final double y = localisationXy[1];
settings.molecules.add(new Molecule(x, y, i, 1));
// Store in pixels
final float xx = (float) (x / nmPerPixel);
final float yy = (float) (y / nmPerPixel);
final float[] params = PeakResult.createParams(0, 0, xx, yy, 0);
settings.results.add(i + 1, (int) xx, (int) yy, 0, 0, 0, 0, params, null);
}
if (settings.molecules.size() > size) {
count++;
if (intraDistances != null) {
final int newCount = settings.molecules.size() - size;
if (newCount == 1) {
// No intra-molecule distances
continue;
}
// Get the distance matrix between these molecules
final double[][] matrix = new double[newCount][newCount];
for (int ii = size, x = 0; ii < settings.molecules.size(); ii++, x++) {
for (int jj = size + 1, y = 1; jj < settings.molecules.size(); jj++, y++) {
final double d2 = settings.molecules.get(ii).distance2(settings.molecules.get(jj));
matrix[x][y] = matrix[y][x] = d2;
}
}
// Get the maximum distance for particle linkage clustering of this molecule
double max = 0;
for (int x = 0; x < newCount; x++) {
// Compare to all-other molecules and get the minimum distance
// needed to join at least one
double linkDistance = Double.POSITIVE_INFINITY;
for (int y = 0; y < newCount; y++) {
if (x == y) {
continue;
}
if (matrix[x][y] < linkDistance) {
linkDistance = matrix[x][y];
}
}
// Check if this is larger
if (max < linkDistance) {
max = linkDistance;
}
}
intraDistances.add(Math.sqrt(max));
}
}
}
settings.results.end();
if (bp != null) {
final ImagePlus imp = ImageJUtils.display(maskTitle, bp);
final Calibration cal = imp.getCalibration();
cal.setUnit("nm");
cal.pixelWidth = cal.pixelHeight = maskScale;
}
log("Simulation results");
log(" * Molecules = %d (%d activated)", xyz.size(), count);
log(" * Blinking rate = %s", MathUtils.rounded((double) settings.molecules.size() / xyz.size(), 4));
log(" * Precision (Mean-displacement) = %s nm", (statsSigma.getN() > 0) ? MathUtils.rounded(Math.sqrt(statsSigma.getMean()), 4) : "0");
if (intraDistances != null) {
if (intraDistances.getN() == 0) {
log(" * Mean Intra-Molecule particle linkage distance = 0 nm");
log(" * Fraction of inter-molecule particle linkage @ 0 nm = 0 %%");
} else {
plot(blinks, "Blinks/Molecule", true);
final double[][] intraHist = plot(intraDistances, "Intra-molecule particle linkage distance", false);
// Determine 95th and 99th percentile
// Will not be null as we requested a non-integer histogram.
int p99 = intraHist[0].length - 1;
final double limit1 = 0.99 * intraHist[1][p99];
final double limit2 = 0.95 * intraHist[1][p99];
while (intraHist[1][p99] > limit1 && p99 > 0) {
p99--;
}
int p95 = p99;
while (intraHist[1][p95] > limit2 && p95 > 0) {
p95--;
}
log(" * Mean Intra-Molecule particle linkage distance = %s nm" + " (95%% = %s, 99%% = %s, 100%% = %s)", MathUtils.rounded(intraDistances.getMean(), 4), MathUtils.rounded(intraHist[0][p95], 4), MathUtils.rounded(intraHist[0][p99], 4), MathUtils.rounded(intraHist[0][intraHist[0].length - 1], 4));
if (settings.distanceAnalysis) {
performDistanceAnalysis(intraHist, p99);
}
}
}
if (settings.clusterSimulation > 0) {
log(" * Cluster number = %s +/- %s", MathUtils.rounded(statsSize.getMean(), 4), MathUtils.rounded(statsSize.getStandardDeviation(), 4));
log(" * Cluster radius = %s +/- %s nm (mean distance to centre-of-mass)", MathUtils.rounded(statsRadius.getMean(), 4), MathUtils.rounded(statsRadius.getStandardDeviation(), 4));
}
}
Aggregations