text:
package Radioactivity_Sim;

public class NucleiSampleBruteForceSim extends PRSFNUM {
	// a container for a group of user defined unstable nuclei and all of the radioactive DecayEvents that they transition through to reach stability
	 /* Variable and Function Nomenclature prescripts:
     * pv = private
     * pr = protected
     * pu = public
     * pvs = private static
     * prs = protected static
     * pus = public static
     * pvsf = private static final
     * prsf = protected static final
     * pusf = public static final
     */

	/*
	 * Inherited Variables and Functions:
	 * protected static final double prsfDoubleZero = 0.0;
	 * protected static final double prsfDoubleOne = 1.0;
	 * protected static final double prsfDoubleTwo = 2.0;
	 * protected static final double prsfDoubleLN2 = 0.69314718;
	 * protected static final double prsfDoubleSQRT2 = 1.414213562;
	 * protected static final double prsfDoubleMinusOne = -1.0;
	 * protected static final double prsfDoubleThousand = 1000.0;
	 * protected static final double prsfDoubleHundred = 100.0;
	 * protected static final double prsfDoubleFiveHundredThousand = 500000;
	 * protected static final double prsfDouble3600 = 3600.0;
	 * protected static final double prsfDoubleThreeHalves = 1.5;
	 * protected static final double prsfDoubleNineTenths = 0.9;
	 * protected static final double prsfDoubleElevenTenths = 1.1;
	 * protected static final int prsfInt8760 = 8760;
	 * protected static final int prsfIntEighty = 80;
	 * protected static final int prsfInt365 = 365;
	 * protected static final int prsfInt24 = 24;
	 * protected static final int prsfInt3600 = 3600;
	 * protected static final int prsfIntZero = 0;
	 * protected static final int prsfIntOne = 1;
	 * protected static final int prsfIntTwo = 2;
	 * protected static final int prsfIntThree = 3
	 * protected static final int prsfIntFour = 4;
	 * protected static final int prsfIntFive = 5;
	 * protected static final int prsfIntSix = 6;
	 * protected static final int[] prsfDetailedTest = ...
	 */

    private DecayEvent[] pvDecayEvents;
    private DecayChainRuleSet[] pvRules;
    private int pvNumDecayChainRuleSets = prsfIntZero;
    private int pvNumDecayEvents = prsfIntZero;
    private double pvStartTime = prsfIntZero;
    private double pvEndTime = prsfIntZero;
    private double[] pvFinalPartNum = new double[prsfIntOne];
    private String[] pvNuclei = new String[prsfIntOne];
    private double pvNucleiStarter = prsfIntZero;

    public NucleiSampleBruteForceSim(int num,String input, double start, double end) {
    	//Constructor for a sample containing a number of nuclei of a single type
    	pvNucleiStarter = Math.random();
        pvNuclei[prsfIntZero] = Double.toString(pvNucleiStarter);
        if (num > prsfIntZero) {
            pvRules = new DecayChainRuleSet[prsfIntOne];
            pvRules[prsfIntZero] = new DecayChainRuleSet(input);
            pvNumDecayChainRuleSets = prsfIntOne;
            pvStartTime = start;
            pvEndTime = end;
            pvDecayEventCalc(num,pvRules[prsfIntZero]);
        } else {
            System.out.println("Construction of this (NucleiSampleBruteForceSim) failed because the (num) supplied was not greater than zero");
        }
    }

    public NucleiSampleBruteForceSim(long num,String input, double start, double end) {
    	//Constructor for a sample containing a number of nuclei of a single type
    	pvNucleiStarter = Math.random();
        pvNuclei[prsfIntZero] = Double.toString(pvNucleiStarter);
        if (num > prsfIntZero) {
            pvRules = new DecayChainRuleSet[prsfIntOne];
            pvRules[prsfIntZero] = new DecayChainRuleSet(input);
            pvNumDecayChainRuleSets = prsfIntOne;
            pvStartTime = start;
            pvEndTime = end;
            pvDecayEventCalcLong(num, pvRules[prsfIntZero]);
        } else {
            System.out.println("Construction of this (NucleiSampleBruteForceSim) failed because the (num) supplied was not greater than zero");
        }
    }

    public NucleiSampleBruteForceSim() {
    	//Constructor for a sample to be user-defined with the (puAddSpecies) function
    	pvNucleiStarter = Math.random();
        pvNuclei[prsfIntZero] = Double.toString(pvNucleiStarter);
    }

    public int puGetNumDecayChainRuleSets() {
    	//Returns the total number of (DecayChainRuleSet) objects
    	return pvNumDecayChainRuleSets;
    }

    public DecayChainRuleSet puGetDecayChainRuleSet(int index) {
    	//Returns the (DecayChainRuleSet) at the specified (index)
    	if(index < prsfIntZero) {
    		String errString = "(puGetDecayChainRuleSet) failed because the supplied (index) is less than zero!";
    		System.out.println(errString);
    		return new DecayChainRuleSet();
    	} else if (index >= pvNumDecayChainRuleSets) {
    		String errString = "(puGetDecayChainRuleSet) failed because the supplied (index) is greater than the total of number of (DecayChainRuleSet) objects in this (NucleiSampleBruteForceSim)!";
    		System.out.println(errString);
    		return new DecayChainRuleSet();
    	} else {
    		return pvRules[index];
    	}
    }

    public void puAddSpecies (int num, String input) {
    	//Adds an integer (num) of nuclei of the type described in data file whose path is the String (input)
    	if (num > prsfIntZero) {
    		pvNumDecayChainRuleSets += prsfIntOne;
            DecayChainRuleSet[] newRules = new DecayChainRuleSet[pvNumDecayChainRuleSets];
            for(int x = prsfIntZero; x<pvNumDecayChainRuleSets-prsfIntOne;x++){
            	newRules[x] = pvRules[x];
            }
            newRules[pvNumDecayChainRuleSets-prsfIntOne] = new DecayChainRuleSet(input);
    		pvRules = newRules;
    		pvDecayEventCalc(num, pvRules[pvNumDecayChainRuleSets-prsfIntOne]);
        } else {
            System.out.println("(puAddSpecies) failed because the input (num) supplied was not greater than zero");
        }
    }

    public void puAddSpecies (long num, String input) {
    	//Adds an integer (num) of nuclei of the type described in data file whose path is the String (input)
    	if (num > prsfIntZero) {
    		pvNumDecayChainRuleSets += prsfIntOne;
            DecayChainRuleSet[] newRules = new DecayChainRuleSet[pvNumDecayChainRuleSets];
            for(int x = prsfIntZero; x<pvNumDecayChainRuleSets-prsfIntOne;x++){
            	newRules[x] = pvRules[x];
            }
            newRules[pvNumDecayChainRuleSets-prsfIntOne] = new DecayChainRuleSet(input);
    		pvRules = newRules;
    		pvDecayEventCalcLong(num, pvRules[pvNumDecayChainRuleSets-prsfIntOne]);
        } else {
            System.out.println("(puAddSpecies) failed because the input (num) supplied was not greater than zero");
        }
    }

    private void pvDecayEventCalc(int num, DecayChainRuleSet rules) {
    	//Function that calculates an integer (num) DecayEvents based on the DecayChainRuleSet (rules)
    	int numRules = rules.puGetNumRules();
    	//Calculate Number of DecayEvents
        String startNucleus = "";
    	double timeOffset = prsfIntZero;
    	for(int x = prsfIntZero; x < rules.puGetNumRules(); x++){
	    	boolean newNucleus = true;
			for(int q = prsfIntZero;q < pvNuclei.length; q++) {
				if(pvNuclei.length ==prsfIntOne){
					if(Double.toString(pvNucleiStarter).compareTo(pvNuclei[prsfIntZero])==prsfIntZero){
						newNucleus = false;
						pvNuclei[prsfIntZero] = rules.puGetStartNucleus(x);
						break;
					}
				}
				if(pvNuclei[q].compareTo(rules.puGetStartNucleus(x))==prsfIntZero){
					newNucleus = false;
				}
			}
			if(newNucleus){
				String[] nuclei = new String[pvNuclei.length+prsfIntOne];
				for(int q = prsfIntZero;q < pvNuclei.length; q++) {
					nuclei[q] = pvNuclei[q];
				}
				nuclei[pvNuclei.length] = rules.puGetStartNucleus(x);
				pvNuclei = nuclei;
			}
    	}
    	for(int x = prsfIntZero; x<num; x++) {
    		timeOffset = prsfIntZero;
    		startNucleus = rules.puGetStartNucleus(prsfIntZero);
    		for(int y = prsfIntZero; y<numRules; y++) {
    			if (rules.puGetStartNucleus(y).compareTo(startNucleus)==prsfIntZero) {
    				if (rules.puGetProbability(y) == prsfIntOne) {
    					startNucleus = rules.puGetEndNucleus(y);
    					DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y));
    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    						pvAddDecayEvent(instance);
    					}
    					timeOffset += instance.puGetTime();
    				} else {
    					double seed = Math.random();
    					if ((rules.puGetProbability(y) + rules.puGetProbability(y+1)) == prsfIntOne) {
    						if (seed <= rules.puGetProbability(y)){
    							startNucleus = rules.puGetEndNucleus(y);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y));
    							if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    	    					y++;
    						} else {
    							startNucleus = rules.puGetEndNucleus(y+prsfIntOne);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y+prsfIntOne));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    							y++;
    						}

    					} else if ((rules.puGetProbability(y) + rules.puGetProbability(y+prsfIntOne) + rules.puGetProbability(y+prsfIntTwo)) == prsfIntOne) {
    						if (seed <= rules.puGetProbability(y)) {
    							startNucleus = rules.puGetEndNucleus(y);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    	    					y += prsfIntTwo;
    						} else if (seed <= (rules.puGetProbability(y) + rules.puGetProbability(y+prsfIntOne))) {
    							startNucleus = rules.puGetEndNucleus(y+1);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y+prsfIntOne));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    							y += prsfIntTwo;
    						} else {
    							startNucleus = rules.puGetEndNucleus(y+prsfIntTwo);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y+prsfIntTwo));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    							y += prsfIntTwo;
    						}

    					} else {
    						System.out.println("(pvDecayEventCalc) failed because the input file contained a bad set of probability rules");
    					}
    				}
    			}
    		}
    	}
    }

    private void pvDecayEventCalcLong(long num, DecayChainRuleSet rules) {
    	//Function that calculates an integer (num) DecayEvents based on the DecayChainRuleSet (rules)
    	int numRules = rules.puGetNumRules();
    	//Calculate Number of DecayEvents
    	String startNucleus = "";
    	double timeOffset = prsfIntZero;
    	for(int x = prsfIntZero; x < rules.puGetNumRules(); x++){
	    	boolean newNucleus = true;
			for(int q = prsfIntZero;q < pvNuclei.length; q++) {
				if(pvNuclei.length ==prsfIntOne){
					if(Double.toString(pvNucleiStarter).compareTo(pvNuclei[prsfIntZero])==prsfIntZero){
						newNucleus = false;
						pvNuclei[prsfIntZero] = rules.puGetStartNucleus(x);
						break;
					}
				}
				if(pvNuclei[q].compareTo(rules.puGetStartNucleus(x))==prsfIntZero){
					newNucleus = false;
				}
			}
			if(newNucleus){
				String[] nuclei = new String[pvNuclei.length+prsfIntOne];
				for(int q = prsfIntZero;q < pvNuclei.length; q++) {
					nuclei[q] = pvNuclei[q];
				}
				nuclei[pvNuclei.length] = rules.puGetStartNucleus(x);
				pvNuclei = nuclei;
			}
    	}
    	for(long x = prsfIntZero; x<num; x++) {
    		timeOffset = prsfIntZero;
    		startNucleus = rules.puGetStartNucleus(prsfIntZero);
    		for(int y = prsfIntZero; y<numRules; y++) {
    			if (rules.puGetStartNucleus(y).compareTo(startNucleus)==prsfIntZero) {
    				if (rules.puGetProbability(y) == prsfIntOne) {
    					startNucleus = rules.puGetEndNucleus(y);
    					DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y));
    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    						pvAddDecayEvent(instance);
    					}
    					timeOffset += instance.puGetTime();
    				} else {
    					double seed = Math.random();
    					if ((rules.puGetProbability(y) + rules.puGetProbability(y+prsfIntOne)) == prsfIntOne) {
    						if (seed <= rules.puGetProbability(y)){
    							startNucleus = rules.puGetEndNucleus(y);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    	    					y++;
    						} else {
    							startNucleus = rules.puGetEndNucleus(y+prsfIntOne);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y+prsfIntOne));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    							y++;
    						}

    					} else if ((rules.puGetProbability(y) + rules.puGetProbability(y+prsfIntOne) + rules.puGetProbability(y+prsfIntTwo)) == prsfIntOne) {
    						if (seed <= rules.puGetProbability(y)) {
    							startNucleus = rules.puGetEndNucleus(y);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    	    					y += 2;
    						} else if (seed <= (rules.puGetProbability(y) + rules.puGetProbability(y+prsfIntOne))) {
    							startNucleus = rules.puGetEndNucleus(y+prsfIntOne);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y+prsfIntOne));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    							y += prsfIntTwo;
    						} else {
    							startNucleus = rules.puGetEndNucleus(y+prsfIntTwo);
    							DecayEvent instance = new DecayEvent(timeOffset, rules.puGetRule(y+prsfIntTwo));
    	    					if (instance.puGetTime()>=pvStartTime&instance.puGetTime()<pvEndTime) {
    	    						pvAddDecayEvent(instance);
    	    					}
    	    					timeOffset += instance.puGetTime();
    							y += prsfIntTwo;
    						}

    					} else {
    						System.out.println("(pvDecayEventCalc) failed because the input file contained a bad set of probability rules");
    					}
    				}
    			}
    		}
    	}
    }

    private void pvAddDecayEvent(DecayEvent instance) {
    	//Adds a (DecayEvent) to this (NucleiSampleBruteForceSim)
    	DecayEvent[] DecayEvents = new DecayEvent[pvNumDecayEvents+1];
    	for(int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    		DecayEvents[x]=pvDecayEvents[x];
    	}
    	DecayEvents[pvNumDecayEvents] = instance;
    	pvDecayEvents = DecayEvents;
    	pvNumDecayEvents++;
    }

    public double[][] puGetAllDecayEventEnergyAndTime() {
    	//returns all calculated (DecayEvent) energies and times
    	if (pvNumDecayEvents > prsfIntZero) {
        	double returned[][] = new double[pvNumDecayEvents][prsfIntTwo];
        	for (int x = prsfIntZero;x<pvNumDecayEvents;x++) {
        		returned[x][prsfIntZero]=pvDecayEvents[x].puGetTime();
        		returned[x][prsfIntOne]=pvDecayEvents[x].puGetEnergy();
        	}
        	return returned;
    	} else {
    		System.out.println("(puGetEnergyAndTime) failed because this (NucleiSampleBruteForceSim) contain no DecayEvents");
    		double returned[][] = new double[prsfIntOne][prsfIntOne];
    		return returned;
    	}
    }

    public int puGetNumDecayEvents(){
    	//returns the number of (DecayEvent)s contained in this (NucleiSampleBruteForceSim)
    	return pvNumDecayEvents;
    }

    public double puGetStartTime(){
    	//returns the (pvStartTime) of this (NucleiSampleBruteForceSim)
    	return pvStartTime;
    }

    public double puGetEndTime(){
    	//returns the (pvEndTime) of this (NucleiSampleBruteForceSim)
    	return pvEndTime;
    }

    public String puGetAllEndTimeNucleiCounts() {
    	//Returns a string containing all of the final counts for all nuclei at (pvEndTime) within this (NucleiSampleBruteForceSim)
    	StringBuilder text = new StringBuilder();
    	text.append("The remaining nuclei counts at "+pvEndTime+" are: " + System.getProperty("line.separator"));
    	text.append("Nucleus,NumberOfNuclei" + System.getProperty("line.separator"));
    	double[] endTimePartNum = new double[pvNuclei.length];
    	for(int x = prsfIntZero; x < pvNumDecayEvents; x++){
    		for(int y = prsfIntZero; y < pvNuclei.length; y++) {
    			if((pvEndTime<pvDecayEvents[x].puGetTime())&(pvEndTime>=pvDecayEvents[x].puGetTimeOffset())&(pvNuclei[y].compareTo(pvDecayEvents[x].puGetStartNucleus())==0)){
    				endTimePartNum[y]++;
    			}
    		}
    	}
    	for(int q = prsfIntZero; q < pvNuclei.length; q++) {
			text.append(pvNuclei[q] + "," + endTimePartNum[q] + System.getProperty("line.separator"));
		}
    	return text.toString();
    }

    public String puGetAllStartTimeNucleiCounts() {
    	//Returns a string containing all of the final counts for all nuclei at (pvEndTime) within this (NucleiSampleBruteForceSim)
    	StringBuilder text = new StringBuilder();
    	text.append("The initial nuclei counts at "+pvStartTime+" are: " + System.getProperty("line.separator"));
    	text.append("Nucleus,NumberOfNuclei" + System.getProperty("line.separator"));
    	double[] startTimePartNum = new double[pvNuclei.length];
    	for(int x = prsfIntZero; x < pvNumDecayEvents; x++){
    		for(int y = prsfIntZero; y < pvNuclei.length; y++) {
    			if((pvStartTime<pvDecayEvents[x].puGetTime())&(pvStartTime>=pvDecayEvents[x].puGetTimeOffset())&(pvNuclei[y].compareTo(pvDecayEvents[x].puGetStartNucleus())==0)){
    				startTimePartNum[y]++;
    			}
    		}
    	}
    	for(int q = prsfIntZero; q < pvNuclei.length; q++) {
			text.append(pvNuclei[q] + "," + startTimePartNum[q] + System.getProperty("line.separator"));
		}
    	return text.toString();
    }

    public String puGetAllEventCountsOverTimeRangeByNuclei(double start, double end) {
    	//Returns a string containing all of the event counts for all nuclei over the specified time range within this (NucleiSampleBruteForceSim)
    	StringBuilder text = new StringBuilder();
    	text.append("The final decay event counts are: " + System.getProperty("line.separator"));
    	text.append("Nucleus,NumberOfEvents" + System.getProperty("line.separator"));
    	for(int q = prsfIntZero; q < pvNuclei.length; q++) {
			text.append(pvNuclei[q] + "," + puGetEventNumForStartNucleusOverTimeRange(start,end,pvNuclei[q]) + System.getProperty("line.separator"));

		}
    	return text.toString();
    }

    public String puGetAllParticleAndEMCountsOverTimeRangeByEnergy(double start, double end){
    	//Returns the number of emissions listed by type and energy that occurred between the user supplied (start) and (end) times
    	String names[] = new String[prsfIntOne];
    	double energies[] = new double[prsfIntOne];
    	double counts[] = new double[prsfIntOne];
    	double test = prsfIntZero;
    	int length = prsfIntZero;
    	StringBuilder text = new StringBuilder();
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetAllParticleAndEMCountsOverTimeRangeByEnergy) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		String err = "Warning (puGetAllParticleAndEMCountsOverTimeRangeByEnergy) was supplied a start time that is past (pvEndTime)!";
    		System.out.println(err);
    		return err;
    	}
    	if (end < pvStartTime) {
    		String err = "Warning (puGetAllParticleAndEMCountsOverTimeRangeByEnergy) was supplied an end time that is earlier than (pvStartTime)!";
    		System.out.println(err);
    		return err;
    	} else if (end > pvEndTime) {
    		String err = "Warning (puGetAllParticleAndEMCountsOverTimeRangeByEnergy) was supplied an end time that is past (pvEndTime)!";
    		System.out.println(err);
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			//Build counts for the independent name and energy pairs
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end) {
    					if(pvDecayEvents[x].puGetNumGammas()>0){
							for(int y = prsfIntZero; y < pvDecayEvents[x].puGetNumGammas(); y++){
								if(length==prsfIntZero){
	    							names[prsfIntZero]=pvDecayEvents[x].puGetGammaName(y);
	    							energies[prsfIntZero]=pvDecayEvents[x].puGetGammaEnergy(y);
	    							counts[prsfIntZero]=pvDecayEvents[x].puGetGammaIntensity(y);
	    							length++;
	    						} else {
	    							boolean isNew = true;
	    							for(int z = prsfIntZero; z < length;z++){
	    								if(pvDecayEvents[x].puGetGammaName(y).compareTo(names[z])==0&pvDecayEvents[x].puGetGammaEnergy(y)==energies[z]){
	    									isNew = false;
	    									counts[z]+=pvDecayEvents[x].puGetGammaIntensity(y);
	    								}
	    							}
	    							if(isNew){
	    								String[] newNames = new String[length+prsfIntOne];
	    								double[] newEnergies = new double[length+prsfIntOne];
	    								double[] newCounts = new double[length+prsfIntOne];
	    								for(int z = prsfIntZero; z < length; z++){
	    									newNames[z] = names[z];
	    									newEnergies[z] = energies[z];
	    									newCounts[z] = counts[z];
	    								}
	    								newNames[length] = pvDecayEvents[x].puGetGammaName(y);
	    								newEnergies[length] = pvDecayEvents[x].puGetGammaEnergy(y);
	    								newCounts[length] = pvDecayEvents[x].puGetGammaIntensity(y);
	    								names = newNames;
	    								energies = newEnergies;
	    								counts = newCounts;
	    								length++;
	    							}
	    						}
							}
						}
						if(pvDecayEvents[x].puGetNumAlphas()>0){
							for(int y = prsfIntZero; y < pvDecayEvents[x].puGetNumAlphas(); y++){
								if(length==prsfIntZero){
	    							names[prsfIntZero]=pvDecayEvents[x].puGetAlphaName(y);
	    							energies[prsfIntZero]=pvDecayEvents[x].puGetAlphaEnergy(y);
	    							counts[prsfIntZero]=pvDecayEvents[x].puGetAlphaIntensity(y);
	    							length++;
	    						} else {
	    							boolean isNew = true;
	    							for(int z = prsfIntZero; z < length;z++){
	    								if(pvDecayEvents[x].puGetAlphaName(y).compareTo(names[z])==0&pvDecayEvents[x].puGetAlphaEnergy(y)==energies[z]){
	    									isNew = false;
	    									counts[z]+=pvDecayEvents[x].puGetAlphaIntensity(y);
	    								}
	    							}
	    							if(isNew){
	    								String[] newNames = new String[length+prsfIntOne];
	    								double[] newEnergies = new double[length+prsfIntOne];
	    								double[] newCounts = new double[length+prsfIntOne];
	    								for(int z = prsfIntZero; z < length; z++){
	    									newNames[z] = names[z];
	    									newEnergies[z] = energies[z];
	    									newCounts[z] = counts[z];
	    								}
	    								newNames[length] = pvDecayEvents[x].puGetAlphaName(y);
	    								newEnergies[length] = pvDecayEvents[x].puGetAlphaEnergy(y);
	    								newCounts[length] = pvDecayEvents[x].puGetAlphaIntensity(y);
	    								names = newNames;
	    								energies = newEnergies;
	    								counts = newCounts;
	    								length++;
	    							}
	    						}
							}
						}
						if(pvDecayEvents[x].puGetNumNeutrons()>0){
							for(int y = prsfIntZero; y < pvDecayEvents[x].puGetNumNeutrons(); y++){
								if(length==prsfIntZero){
	    							names[prsfIntZero]=pvDecayEvents[x].puGetNeutronName(y);
	    							energies[prsfIntZero]=pvDecayEvents[x].puGetNeutronEnergy(y);
	    							counts[prsfIntZero]=pvDecayEvents[x].puGetNeutronIntensity(y);
	    							length++;
	    						} else {
	    							boolean isNew = true;
	    							for(int z = prsfIntZero; z < length;z++){
	    								if(pvDecayEvents[x].puGetNeutronName(y).compareTo(names[z])==0&pvDecayEvents[x].puGetNeutronEnergy(y)==energies[z]){
	    									isNew = false;
	    									counts[z]+=pvDecayEvents[x].puGetNeutronIntensity(y);
	    								}
	    							}
	    							if(isNew){
	    								String[] newNames = new String[length+prsfIntOne];
	    								double[] newEnergies = new double[length+prsfIntOne];
	    								double[] newCounts = new double[length+prsfIntOne];
	    								for(int z = prsfIntZero; z < length; z++){
	    									newNames[z] = names[z];
	    									newEnergies[z] = energies[z];
	    									newCounts[z] = counts[z];
	    								}
	    								newNames[length] = pvDecayEvents[x].puGetNeutronName(y);
	    								newEnergies[length] = pvDecayEvents[x].puGetNeutronEnergy(y);
	    								newCounts[length] = pvDecayEvents[x].puGetNeutronIntensity(y);
	    								names = newNames;
	    								energies = newEnergies;
	    								counts = newCounts;
	    								length++;
	    							}
	    						}
							}
						}
						if(pvDecayEvents[x].puGetNumBetas()>0){
							for(int y = prsfIntZero; y < pvDecayEvents[x].puGetNumBetas(); y++){
								if(length==prsfIntZero){
	    							names[prsfIntZero]=pvDecayEvents[x].puGetBetaName(y);
	    							energies[prsfIntZero]=pvDecayEvents[x].puGetBetaEnergy(y);
	    							counts[prsfIntZero]=pvDecayEvents[x].puGetBetaIntensity(y);
	    							length++;
	    						} else {
	    							boolean isNew = true;
	    							for(int z = prsfIntZero; z < length;z++){
	    								if(pvDecayEvents[x].puGetBetaName(y).compareTo(names[z])==0&pvDecayEvents[x].puGetBetaEnergy(y)==energies[z]){
	    									isNew = false;
	    									counts[z]+=pvDecayEvents[x].puGetBetaIntensity(y);
	    								}
	    							}
	    							if(isNew){
	    								String[] newNames = new String[length+prsfIntOne];
	    								double[] newEnergies = new double[length+prsfIntOne];
	    								double[] newCounts = new double[length+prsfIntOne];
	    								for(int z = prsfIntZero; z < length; z++){
	    									newNames[z] = names[z];
	    									newEnergies[z] = energies[z];
	    									newCounts[z] = counts[z];
	    								}
	    								newNames[length] = pvDecayEvents[x].puGetBetaName(y);
	    								newEnergies[length] = pvDecayEvents[x].puGetBetaEnergy(y);
	    								newCounts[length] = pvDecayEvents[x].puGetBetaIntensity(y);
	    								names = newNames;
	    								energies = newEnergies;
	    								counts = newCounts;
	    								length++;
	    							}
	    						}
							}
						}
    				}
    			}
    			text.append("From t = " + start + " to t = " + end + ", the following emissions occur:" + System.getProperty("line.separator"));
    			text.append("Names, Energy[MeV], Counts" + System.getProperty("line.separator"));
    			for(int x = prsfIntZero; x < length; x++){
    				text.append(names[x] + ", " + energies[x] + ", " + counts[x] + System.getProperty("line.separator"));
    			}
    		} else {
    			String err = "(puGetAllParticleAndEMCountsOverTimeRangeByEnergy) failed because this (NucleiSampleBruteForceSim) contain no (DecayEvent)s";
    			System.out.println(err);
    			return err;
    		}
    	} else {
    		String err = "(puGetAllParticleAndEMCountsOverTimeRangeByEnergy) failed because the supplied start time was greater than the supplied end time!";
    		System.out.println(err);
			return err;
    	}
    	return(text.toString());
    }

    public String puGetAllDecayEventData() {
    	//Returns a complete set of this (NucleiSampleBruteForceSims)'s (DecayEvent) data
    	if (pvNumDecayEvents > prsfIntZero) {
        	StringBuilder text = new StringBuilder();
        	text.append("Occurence_Time(s),StartingNucleus,EndingNucleus,Type,Energy(MeV)" + System.getProperty("line.separator"));
        	for (int x = prsfIntZero;x<pvNumDecayEvents;x++) {
        		text.append(pvDecayEvents[x].puGetTime() + "," + pvDecayEvents[x].puGetStartNucleus() + "," + pvDecayEvents[x].puGetEndNucleus() + "," + pvDecayEvents[x].puGetType() + "," + pvDecayEvents[x].puGetEnergy() + System.getProperty("line.separator"));
        	}
        	return text.toString();
    	} else {
    		System.out.println("(puGetAllDecayEventData) failed because this (NucleiSampleBruteForceSim) contain no DecayEvents");
    		return "";
    	}
    }

    public double puGetEventNumForTypeOverTimeRange(double start, double end, String type) {
    	//Returns the number of events with the supplied (type) that occurred between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForTypeOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForTypeOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForTypeOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForTypeOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&type.compareTo(pvDecayEvents[x].puGetType())==prsfIntZero) {
    					sum++;
    				}
    			}
    		} else {
    			System.out.println("(puGetEventNumForTypeOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEventSet)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEventNumForTypeOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEventNumForTypeAndStartNOverTimeRange(double start, double end, String type, String startN) {
    	//Returns the number of events with the supplied (type) and (startN) that occurred between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForTypeAndStartNOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForTypeAndStartNOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForTypeAndStartNOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForTypeAndStartNOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&type.compareTo(pvDecayEvents[x].puGetType())==prsfIntZero&startN.compareTo(pvDecayEvents[x].puGetStartNucleus())==prsfIntZero) {
    					sum++;
    				}
    			}
    		} else {
    			System.out.println("(puGetEventNumForTypeAndStartNOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEventSet)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEventNumForTypeAndStartNOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEventNumForStartNucleusOverTimeRange(double start, double end, String startN) {
    	//Returns the number of events with the supplied (startN) that occurred between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForStartNucleusOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForStartNucleusOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForStartNucleusOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForStartNucleusOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&startN.compareTo(pvDecayEvents[x].puGetStartNucleus())==prsfIntZero) {
    					sum++;
    				}
    			}
    		} else {
    			System.out.println("(puGetEventNumForStartNucleusOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEventSet)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEventNumForStartNucleusOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEventNumForEndNucleusOverTimeRange(double start, double end, String endN) {
    	//Returns the number of events with the supplied (endN) that occurred between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&endN.compareTo(pvDecayEvents[x].puGetEndNucleus())==prsfIntZero) {
    					sum++;
    				}
    			}
    		} else {
    			System.out.println("(puGetEventNumForEndNucleusOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEventSet)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEventNumForEndNucleusOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEventNumOverTimeRange(double start, double end) {
    	//Returns the number of events that occurred between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEventNumForEndNucleusOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end) {
    					sum++;
    				}
    			}
    		}  else {
    			System.out.println("(puGetEventNumForEndNucleusOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEventSet)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEventNumForEndNucleusOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEnergySumForTypeOverTimeRange(double start, double end, String type) {
    	//Returns the total energy in MeV for the supplied (type) that was radiated between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForTypeOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForTypeOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForTypeOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForTypeOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&type.compareTo(pvDecayEvents[x].puGetType())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}

    			}
    		} else {
    			System.out.println("(puGetEnergySumForTypeOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEvent)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEnergySumForTypeOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEnergySumForStartingNucleusOverTimeRange(double start, double end, String startN) {
    	//Returns the total energy in MeV for the supplied (startN) that was radiated between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForStartingNucleusOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForStartingNucleusOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForStartingNucleusOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForStartingNucleusOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&startN.compareTo(pvDecayEvents[x].puGetStartNucleus())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}

    			}
    		} else {
    			System.out.println("(puGetEnergySumForStartingNucleusOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEvent)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEnergySumForStartingNucleusOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEnergySumForEndingNucleusOverTimeRange(double start, double end, String endN) {
    	//Returns the total energy in MeV for the supplied (endN) that was radiated between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForEndingNucleusOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForEndingNucleusOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForEndingNucleusOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForEndingNucleusOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&endN.compareTo(pvDecayEvents[x].puGetEndNucleus())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}

    			}
    		} else {
    			System.out.println("(puGetEnergySumForEndingNucleusOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEvent)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEnergySumForEndingNucleusOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEnergySumForTypeAndStartNOverTimeRange(double start, double end, String type, String startN) {
    	//Returns the total energy in MeV for the supplied (startN) and (type) that was radiated between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForTypeAndStartNOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForTypeAndStartNOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumForTypeAndStartNOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumForTypeAndStartNOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				if (startN.compareTo(pvDecayEvents[x].puGetStartNucleus())==prsfIntZero&type.compareTo(pvDecayEvents[x].puGetType())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}
    			}
    		} else {
    			System.out.println("(puGetEnergySumForTypeAndStartNOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEventSet)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEnergySumForTypeAndStartNOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetEnergySumOverTimeRange(double start, double end) {
    	//Returns the total energy in MeV radiated between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetEnergySumOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetEnergySumOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}
    			}
    		} else {
    			System.out.println("(puGetEnergySumOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no (DecayEvent)s");
    			return prsfIntZero;
    		}
    	} else {
    		System.out.println("(puGetEnergySumOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    	}
    	return sum;
    }

    public double puGetRadiatedPowerOverTimeRange(double start, double end) {
    	//Returns the radiated power in MeV/s between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}
    			 }
    		} else {
    			System.out.println("(puGetRadiatedPowerOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no particles");
    			return prsfIntZero;
    		}

    	} else {
    		System.out.println("(puGetRadiatedPowerOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    		return prsfIntZero;
    	}
    	return (sum/(end-start));
    }

    public double puGetRadiatedPowerForTypeAndStartNOverTimeRange(double start, double end, String type, String startN) {
    	//Returns the radiated power in MeV/s for the supplied (type) and (startN) between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeAndStartNOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeAndStartNOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeAndStartNOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeAndStartNOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&type.compareTo(pvDecayEvents[x].puGetType())==prsfIntZero&startN.compareTo(pvDecayEvents[x].puGetStartNucleus())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}
    			 }
    		} else {
    			System.out.println("(puGetRadiatedPowerForTypeAndStartNOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no particles");
    			return prsfIntZero;
    		}

    	} else {
    		System.out.println("(puGetRadiatedPowerForTypeAndStartNOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    		return prsfIntZero;
    	}
    	return (sum/(end-start));
    }

    public double puGetRadiatedPowerForTypeOverTimeRange(double start, double end, String type) {
    	//Returns the radiated power in MeV/s for the supplied (type) between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForTypeOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&type.compareTo(pvDecayEvents[x].puGetType())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}
    			 }
    		} else {
    			System.out.println("(puGetRadiatedPowerForTypeOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no particles");
    			return prsfIntZero;
    		}

    	} else {
    		System.out.println("(puGetRadiatedPowerForTypeOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    		return prsfIntZero;
    	}
    	return (sum/(end-start));
    }

    public double puGetRadiatedPowerForStartNucleusOverTimeRange(double start, double end, String startN) {
    	//Returns the radiated power in MeV/s for the supplied (startN) between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForStartNucleusOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForStartNucleusOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForStartNucleusOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForStartNucleusOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&startN.compareTo(pvDecayEvents[x].puGetStartNucleus())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}
    			 }
    		} else {
    			System.out.println("(puGetRadiatedPowerForStartNucleusOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no particles");
    			return prsfIntZero;
    		}

    	} else {
    		System.out.println("(puGetRadiatedPowerForStartNucleusOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    		return prsfIntZero;
    	}
    	return (sum/(end-start));
    }

    public double puGetRadiatedPowerForEndNucleusOverTimeRange(double start, double end, String endN) {
    	//Returns the radiated power in MeV/s for the supplied (endN) between the user supplied (start) and (end) times
    	double sum = prsfIntZero;
    	double test = prsfIntZero;
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForEndNucleusOverTimeRange) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForEndNucleusOverTimeRange) was supplied a start time that is past (pvEndTime)!");
    		return sum;
    	}
    	if (end < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForEndNucleusOverTimeRange) was supplied an end time that is earlier than (pvStartTime)!");
    		return sum;
    	} else if (end > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForEndNucleusOverTimeRange) was supplied an end time that is past (pvEndTime)!");
    	}
    	if (start < end) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				test = pvDecayEvents[x].puGetTime();
    				if (test>=start&test<end&endN.compareTo(pvDecayEvents[x].puGetEndNucleus())==prsfIntZero) {
    					sum += pvDecayEvents[x].puGetEnergy();
    				}
    			 }
    		} else {
    			System.out.println("(puGetRadiatedPowerForEndNucleusOverTimeRange) failed because this (NucleiSampleBruteForceSim) contain no particles");
    			return prsfIntZero;
    		}

    	} else {
    		System.out.println("(puGetRadiatedPowerForEndNucleusOverTimeRange) failed because the supplied start time was greater than the supplied end time!");
    		return prsfIntZero;
    	}
    	return (sum/(end-start));
    }

    public String puGetRadiatedPowerForOneYear(double start) {
    	//Returns a comma delimited String with a years worth of radiated power MeV/s (one per hour) calculations starting at time (start)
    	double[] aveBucket = new double[prsfInt8760];
    	for (int x = prsfIntZero; x<prsfInt8760; x++) {
    		aveBucket[x] = prsfIntZero;
    	}
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYear) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYear) was supplied a start time that is past (pvEndTime)!");
    		return "Warning (puGetRadiatedPowerForOneYear) was supplied a start time that is past (pvEndTime)!";
    	}
    	if (start >= prsfIntZero) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				for (int y = prsfIntZero; y < prsfInt8760; y++) {
    					if(((pvDecayEvents[x].puGetTime())>=(start+prsfDouble3600*y))&((pvDecayEvents[x].puGetTime())<(start+prsfDouble3600*(y+prsfIntOne)))){
    						aveBucket[y] = aveBucket[y] + pvDecayEvents[x].puGetEnergy();
    					}
    				}
    			}
    			StringBuilder text = new StringBuilder();
    			text.append("Averages are of the (DecayEvent)s occurring between each of the Times below and the next one" + System.getProperty("line.separator"));
    			text.append("Time,AverageEnergy(MeV/s)" + System.getProperty("line.separator"));
    			for (int x = prsfIntZero;x<prsfInt8760;x++) {
    				aveBucket[x] = aveBucket[x]/prsfDouble3600;
    				text.append((start+prsfDouble3600*x) + "," + aveBucket[x] + System.getProperty("line.separator"));
    			}
    			return text.toString();
    		} else {
    			System.out.println("(puGetRadiatedPowerForOneYear) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s");
    			return "(puGetRadiatedPowerForOneYear) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s";
    		}
    	} else {
    		System.out.println ("(puGetRadiatedPowerForOneYear) failed because the supplied start time is less than zero");
    		return "(puGetRadiatedPowerForOneYear) failed because the supplied start time is less than zero";
    	}
    }

    public String puGetRadiatedPowerForOneYearForType(double start, String type) {
    	//Returns a comma delimited String with a years worth of radiated power MeV/s (one per hour) calculations starting at time (start) of only the specified (type)
    	double[] aveBucket = new double[prsfInt8760];
    	for (int x = 0; x<prsfInt8760; x++) {
    		aveBucket[x] = prsfIntZero;
    	}
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYearForType) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYearForType) was supplied a start time that is past (pvEndTime)!");
    		return "Warning (puGetRadiatedPowerForOneYearForType) was supplied a start time that is past (pvEndTime)!";
    	}
    	if (start >= prsfIntZero) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				for (int y = prsfIntZero; y < prsfInt8760; y++) {
    					if((type.compareTo(pvDecayEvents[x].puGetType())==prsfIntZero)&((pvDecayEvents[x].puGetTime())>=(start+prsfDouble3600*y))&((pvDecayEvents[x].puGetTime())<(start+prsfDouble3600*(y+prsfIntOne)))){
    						aveBucket[y] = aveBucket[y] + pvDecayEvents[x].puGetEnergy();
    					}
    				}
    			}
    			StringBuilder text = new StringBuilder();
    			text.append("Averages are of the (DecayEvent)s occurring between each of the Times below and the next one" + System.getProperty("line.separator"));
    			text.append("Time,AverageEnergy(MeV/s)" + System.getProperty("line.separator"));
    			for (int x = prsfIntZero;x<prsfInt8760;x++) {
    				aveBucket[x] = aveBucket[x]/prsfDouble3600;
    				text.append((start+prsfDouble3600*x) + "," + aveBucket[x] + System.getProperty("line.separator"));
    			}
    			return text.toString();
    		} else {
    			System.out.println("(puGetRadiatedPowerForOneYearForType) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s");
    			return "(puGetRadiatedPowerForOneYearForType) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s";
    		}
    	} else {
    		System.out.println ("(puGetRadiatedPowerForOneYearForType) failed because the supplied start time is less than zero");
    		return "(puGetRadiatedPowerForOneYearForType) failed because the supplied start time is less than zero";
    	}
    }

    public String puGetRadiatedPowerForOneYearForStartNucleus(double start, String startN) {
    	//Returns a comma delimited String with a years worth of radiated power MeV/s (one per hour) calculations starting at time (start) of only the specified (startN)
    	double[] aveBucket = new double[prsfInt8760];
    	for (int x = prsfIntZero; x<prsfInt8760; x++) {
    		aveBucket[x] = prsfIntZero;
    	}
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYearForStartNucleus) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYearForStartNucleus) was supplied a start time that is past (pvEndTime)!");
    		return "Warning (puGetRadiatedPowerForOneYearForStartNucleus) was supplied a start time that is past (pvEndTime)!";
    	}
    	if (start >= prsfIntZero) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				for (int y = prsfIntZero; y < prsfInt8760; y++) {
    					if((startN.compareTo(pvDecayEvents[x].puGetStartNucleus())==prsfIntZero)&((pvDecayEvents[x].puGetTime())>=(start+prsfDouble3600*y))&((pvDecayEvents[x].puGetTime())<(start+prsfDouble3600*(y+prsfIntOne)))){
    						aveBucket[y] = aveBucket[y] + pvDecayEvents[x].puGetEnergy();
    					}
    				}
    			}
    			StringBuilder text = new StringBuilder();
    			text.append("Averages are of the (DecayEvent)s occurring between each of the Times below and the next one" + System.getProperty("line.separator"));
    			text.append("Time,AverageEnergy(MeV/s)" + System.getProperty("line.separator"));
    			for (int x = prsfIntZero;x<prsfInt8760;x++) {
    				aveBucket[x] = aveBucket[x]/prsfDouble3600;
    				text.append((start+prsfDouble3600*x) + "," + aveBucket[x] + System.getProperty("line.separator"));
    			}
    			return text.toString();
    		} else {
    			System.out.println("(puGetRadiatedPowerForOneYearForStartNucleus) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s");
    			return "(puGetRadiatedPowerForOneYearForStartNucleus) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s";
    		}
    	} else {
    		System.out.println ("(puGetRadiatedPowerForOneYearForStartNucleus) failed because the supplied start time is less than zero");
    		return "(puGetRadiatedPowerForOneYearForStartNucleus) failed because the supplied start time is less than zero";
    	}
    }

    public String puGetRadiatedPowerForOneYearForEndNucleus(double start, String endN) {
    	//Returns a comma delimited String with a years worth of radiated power MeV/s (one per hour) calculations starting at time (start) of only the specified (endN)
    	double[] aveBucket = new double[prsfInt8760];
    	for (int x = 0; x<prsfInt8760; x++) {
    		aveBucket[x] = prsfIntZero;
    	}
    	if (start < pvStartTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYearForEndNucleus) was supplied a start time that is earlier than (pvStartTime)!");
    	} else if (start > pvEndTime) {
    		System.out.println("Warning (puGetRadiatedPowerForOneYearForEndNucleus) was supplied a start time that is past (pvEndTime)!");
    		return "Warning (puGetRadiatedPowerForOneYearForEndNucleus) was supplied a start time that is past (pvEndTime)!";
    	}
    	if (start >= prsfIntZero) {
    		if (pvNumDecayEvents > prsfIntZero) {
    			for (int x = prsfIntZero; x < pvNumDecayEvents; x++) {
    				for (int y = prsfIntZero; y < prsfInt8760; y++) {
    					if((endN.compareTo(pvDecayEvents[x].puGetEndNucleus())==prsfIntZero)&((pvDecayEvents[x].puGetTime())>=(start+prsfDouble3600*y))&((pvDecayEvents[x].puGetTime())<(start+prsfDouble3600*(y+prsfIntOne)))){
    						aveBucket[y] = aveBucket[y] + pvDecayEvents[x].puGetEnergy();
    					}
    				}
    			}
    			StringBuilder text = new StringBuilder();
    			text.append("Averages are of the (DecayEvent)s occurring between each of the Times below and the next one" + System.getProperty("line.separator"));
    			text.append("Time,AverageEnergy(MeV/s)" + System.getProperty("line.separator"));
    			for (int x = prsfIntZero;x<prsfInt8760;x++) {
    				aveBucket[x] = aveBucket[x]/prsfDouble3600;
    				text.append((start+prsfDouble3600*x) + "," + aveBucket[x] + System.getProperty("line.separator"));
    			}
    			return text.toString();
    		} else {
    			System.out.println("(puGetRadiatedPowerForOneYearForEndNucleus) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s");
    			return "(puGetRadiatedPowerForOneYearForEndNucleus) failed because this (NucleiSampleBruteForceSim) contains no (DecayEvent)s";
    		}
    	} else {
    		System.out.println ("(puGetRadiatedPowerForOneYearForEndNucleus) failed because the supplied start time is less than zero");
    		return "(puGetRadiatedPowerForOneYearForEndNucleus) failed because the supplied start time is less than zero";
    	}
    }

}


Short-term synaptic depression, caused by depletion of releasable neurotransmitter vesicles, modulates the strength of neuronal connections in an activity-dependent manner [1, 2]. Quantifying the statistics of this form of synaptic transmission requires the development of stochastic models linking probabilistic neurotransmitter release with the spike-train statistics of the presynaptic population [3, 4]. A common approach has been to model the presynaptic spike train as either regular or a memory-less Poisson process  - few analytical results are available that describe the behaviour of a depressing synapse when the afferent spike train has more complex, temporally correlated statistics.
Recently, we have derived a series of results that allow for the fraction of occupied release sites and the neurotransmitter release probability to be calculated for a presynaptic spike train with arbitrary interspike interval (ISI) statistics. The results take a particularly compact form when the presynaptic spike times are generated by a renewal process, i.e. when the ISIs are independent. This encompasses a broad range of models that are currently used for circuit and network analyses, including the class of integrate-and-fire models. Our approach also allows for the postsynaptic voltage mean and variance to be calculated, which in turn allows for an approximation of the firing rate of a neuron driven by depressing synapses from non-Poissonian presynaptic neurons (Figure 1).
Predictions of postsynaptic firing rates as a function of the regularity of the renewal process governing presynaptic firing. Presynaptic interspike intervals are independently identically gamma distributed with shape parameter α (increasing α gives more regular firing) and mean 1/R α . Simulated rates are shown as circles with error bars. Analytic predictions are shown as solid lines based on exact forms for the postsynaptic voltage mean and variance.
These results will allow for the incorporation of more complex and physiologically relevant firing patterns into future analytic studies of neuronal circuits and networks.


Welcome to the Isagenix program that I have successfully used with my Practice Members and for my own health & life since 2006. I first test drove this with my wife because anything that I do for my clients, I am already doing it in my own life or have done it for myself. After a few short days we had noticeable changes in our body physiology and by the end of the program, we had excellent results. Not only did I get as lean as I was back in my high school days, I also dropped 10 minutes off my half-marathon time, which was one of my best races in 7 years. My wife also had very good results and fit into a pair of jeans that our teenage daughter (at that time) was wearing!
This program helps to not only address the Chemical Stress aspect of the Vertebral Subluxation or Nerve Interference Patterns, but it also puts the body into a more Alkaline state, which is very healthy for the body. Research studies show that arthritic conditions and cancers are less viable in an Alkaline environment.
By introducing higher quality nutrients in fewer calories and making it easy to comply and follow, allows people to kick start their health with very positive results and inspires them to continue to get to their health goals. The Cleanse Days also place your body into a natural positive anabolic state that helps to increase fat metabolism and put on lean muscle. If you are under a lot of stress, feel overweight, or tired even if you are exercising or just want to have more energy, then this program can help answer those needs.
Go to www.dr-rick.isagenix.com to watch some videostreams and for more information about this leading edge program!


On 2012-12-04	was played the match live in the UEFA Champions League	between Schalke 04	and Montpellier	.
Montpelier after five matches In current season of euro pean cups has only one point and five scored goals. Previously Montpelier lost at Emirates Stadium with Arsenal London null to two after very bad play. Schalke 04 Gelsenkirchen has eleven points and nine scored goals. Previously Schalke 04 Gelsenkirchen won with Olympiacos Piraeus one to null after goal scored by Christian Fuchs. Schalke 04 is a favorite In this match.
Watch online Montpellier - Schalke 04. Only here best live streams free TV. Live stream Montpellier - Schalke 04 during UEFA Champions League seems to be really interesting. Have lots of fun watching the live game.


text:
The S48TL-1 with its unique automatic swing arm operation and patented variable height turntable is designed to meet the demands of today's market.
The S48TL comes as standard with a patented lever-less mounting/demounting tool head. The height of the mount/demount head is set using lever-less pneumatic control. When changing wide Tyres on Tyre changes with a single height turntable, the top of the wheel rim is so high that it is at an uncomfortable and inefficient height, making it difficult to fit and remove Tyres. Not so with the S48TL, by simply lowering the variable height turntable, the top of the wheel rim is positioned at an ergonomic height, making the fitting operation simple.
The back post on the S48TL has been specially positioned to allow the fitting of more specialist wheels and Tyres. Assemblies with an overall Tyre diameter of up to 44" as found on the larger off-road vehicles can be changed on the S48TL. Like all Sice heavy duty models, the S48TL is fitted with two control plates to operate the rim clamping mechanism, this system ensures concentric clamping of the wheel, greatly reducing the risk of rim damage on even the toughest of tyre and wheel assemblies.
The adjustable bead breaker blade and large Tyre test pad ensure that the bead breaker blade is always at the correct angle regardless of the rim width, this means maximum bead breaker power. The two speed 1 phase inverter-fed motor results in fast and efficient tyre removal.
New Automatic tyre changer with lever-less technology
Automatic swing arm saves re-positioning time and space
Lever-less pneumatic control
Self-centering four-jaw chuck
Turntable positioning adjustable in height (patented)
Two pneumatic clamping cylinders
Clockwise and anticlockwise rotation of the turntable through 2 speed, 1 phase electric inverter motor
Electric supply 1 phase with motor-inverter
Double speed of the turntable (smooth ramp)
Double acting bead breaker cylinder
Three-way adjustable blade angle and enlarged wheel pad
Tyre Search
Width 11 12 13 24 26 30 31 32 33 35 37 60 70 80 85 90 95 100 105 110 115 120 125 130 135 140 145 150 155 160 165 170 175 180 185 190 195 200 205 210 215 220 225 230 235 240 245 250 255 260 265 275 280 285 295 300 305 315 325 335 345 350 355 385 400 410 425 450 600 650 670 750
Profile 16 35 40 45 50 55 60 65 70 75 80
Rim size 14 15 16 17 19
Speed Any H - 130mph Q - 99mph T - 118mph V - 149mph W - 168mph Y - 186mph

redpajama_set_name: RedPajamaCommonCrawl


text:
Dallas Stars Loan Defenseman Stephen Johns to Texas on Conditioning Assignment
FRISCO, Texas – Dallas Stars General Manager Jim Nill announced today that the club has loaned defenseman Stephen Johns to the Texas Stars on a conditioning assignment.
Johns, 27, missed the entire 2018-19 season and has yet to play in 2019-20 due to post-traumatic headaches. The defenseman registered 15 points (8-7=15) in 75 regular-season games with Dallas in 2017-18 and has posted 28 points (13-15=28) in 150 career regular-season NHL games, all in a Stars sweater. Johns has also appeared in 13 career postseason games, earning 41 hits and 10 blocked shots during the 2016 Stanley Cup Playoffs.
The 6-foot-4, 225-pound native of Ellwood City, Pa. was originally selected by Chicago in the second round (60th overall) of the 2010 NHL Draft and was acquired by Dallas via trade along with forward Patrick Sharp in exchange for defenseman Trevor Daley and forward Ryan Garbutt on July 12, 2015.
The Stars continue a six-game home stint on Friday as they welcome the Toronto Marlies back to Cedar Park for the first time since the 2018 Calder Cup Final. Puck drop is slated for 7:00 p.m.
Photo Credit: Texas Stars


text:
Annual Huddle 2020
Panellists & Preceptors
© 2020 JUMPstart.
- The Success of Roceso Technologies
Events, Insights
The Success of Roceso Technologies
JUMPstart Medtech on 18 August 2020
We touch base with JUMPstart's star, Ms Jane Wang, on her journey as an entrepreneur.
Founded in 2016, Roceso Technologies aims to bring independence and dignity back to people's life through rehabilitation of stroke and orthopedic injuries. Disability after stroke is a significant outcome that leads to personal suffering and burden on their families.
The journey so far…
Starting out as a research project under A/Prof. Yeow Chen Hua at the NUS Department of Biomedical Engineering, Roceso Technologies has successfully commercialised the NUS background IP into a scalable product and service. Since 2018, the company has set up ISO13485:2016 Quality Manufacturing System with a full scope of Design and Development, Manufacturing, Distribution and Storage. Their flagship product EsoGLOVE™, a soft robotic exoskeleton for hand rehabilitation of stroke patients to enable Activities of Daily Living (ADL) have completed FDA Registration, CE Class 2a approval and HSA Class B approval. They have signed up with distributors in Taiwan, Hong Kong, India, and Ukraine and in the process of registering and signing distribution contracts in Japan and Korea. Recently, a German JV has been setup with their partner Moveri to start commercialization activities in EU market.
Overcoming the initial struggles…
Although the company faced teething troubles, Roceso Technologies and the founders focused on a design thinking approach at the early stage of product development for EsoGLOVE Pro. The patient journey and design requirements were drafted out with inputs from potential customers and users and the team also conducted various risk analysis processes to mitigate risk and ensure the product meets the requirements. "Many start-ups treat these necessary processes and quality management system as a burden, and they do it only to pass audit. But with a proper medical device design control process, there is less chance for us to make major mistakes which may require a pivot." reflects Ms. Jane Wang, the CEO of the company. Further support in the way of NUS Enterprise GRIP grant and the JUMPstart program offered an accelerated way to empower the founders, Ms. Jane Wang and Dr. Yap Hong Kai with the industry and domain knowledge necessary for their entrepreneurial journey. "We did not have systematic knowledge about medical device regulations, quality management system and commercialization. With JUMPstart, we also built a network of entrepreneurs who grow together and support one another in the journey." adds Ms. Jane.
Many start-ups treat these necessary processes and quality management system as a burden, and they do it only to pass audit. But with a proper medical device design control process, there is less chance for us to make major mistakes which may require a pivot.
On Regulated Nature of Medical Device Innovation
When asked about the challenges they faced as a medical device innovator, the founder stresses on the regulated nature of medical device innovation. "Medical device innovation is highly complex and regulated compared to general tech-innovation. Time to market is generally much longer due to the whole process necessary for regulatory approvals. To achieve efficacy and safety, a structured way of design and development is needed with risk analysis and design validation. Product launches can be slow due to regulatory and healthcare system variations. However, due to the regulated nature of medical device innovation, there are less creativity involved in terms of business model and design compared to general tech-innovation."
The two important things to note are:
Product tests have to fulfill various local and international standards before even submitting for regulatory approval in various countries.
On expansion and fundraising…
Having successfully expanded the start-up, we asked Ms. Jane to shine light on the fundraising for medical device innovation. While she agrees fundraising for early stage med-tech innovations have challenges attracting investors' attention due to the long time-to-market and complexity in commercialization, she believe the key is for start-ups to carefully draft a business plan and pitch not only from technology and business point of view but also from investment return point of view to speak the same language with investors.
The key is to draft a business plan from a return on investment perspective as well as speak the same language as the investors.
Innovating in COVID-19 times…
Further, in these difficult times of COVID-19, the company has been quick to pivot on creating revenue generation streams by exploring the rehabilitation-robot rental business and launched their VielyTM brand for more online revenue. They have temporarily supplied PPEs internationally and at the same time, the team shifted focus to important matters such as preparation for our international expansion and upcoming audits, such that we are ready when governments are easing the measures and economies are open.
To all start-ups, Ms. Jane has three quick success mantras:
Stay resilient.
Stay lean at an early stage
Speak the other party's language.
Ms. Jane was working in a European management consulting firm as a Senior Consultant, before founding Roceso Technologies in 2016. Her role consisted of business development, consultancy project management and execution. She also has experience in engineering, intellectual property and human resources.
A self-driven entrepreneur she has always been interested in starting her own business and has a strong interest in medicine and healthcare. She believes in doing good by doing well and finds med-tech to be a great combination of my personal interests and experience to achieve that in her life.
Often an idea alone is often not enough to become a MedTech success, however, the best entrepreneurs are those who maximize all the support available in their ecosystem to become next big stars. Just as in Ms. Jane's journey, choosing the right accelerator and support mechanism can deeply impact your success rate at commercialsation.
At JUMPstart (Joint University MedTech Programme), we drive innovative biomedical research to new venture creation through an integrated product and business development approach. Learn more about our program and join us to gain unprecedented access to a modular and customized program that boosts your chance at finding commercial success.
Are you a MedTech or HealthTech innovator? Write to us at jumpstart@nus.edu.sg to discuss how we can help you.
FounderStart Success Story
JUMPstart Medtech 2020-08-18T11:45:23+08:00
Previous Post (p)	Cracking the US Market with Frank Jaskulke
© 2020 JUMPstart. All Rights Reserved.
Our site uses cookies to optimise your browsing experience. Learn more about our use of cookies here.


text:
'Religious freedom is important for all of society,' Cardinal Dolan says
By (CNA/EWTN)
7/2/2019 (2 weeks ago)
Cardinal Timothy Dolan of New York championed the importance of religious freedom at a patriotic-themed gathering in Utah on Sunday, appearing with religious leaders of the Church of Jesus Christ of Latter-day Saints.
Published in U.S.
Salt Lake City, Utah, (CNA) - "We come together as neighbors, we come together as a family, we come together as friends," Cardinal Dolan said. "See, that gives a counterexample to those who would love to caricature us as these bigoted, hateful, violent people. And we can't allow that to happen."
The Cardinal added that religious freedom "is important for all of culture and all of society, not just for people of faith."
Your Prayer Requests 'LIVE'
Cardinal Dolan gave the keynote address to a crowd of 3,000 at Utah Valley University UCCU Center in Orem, Utah, on Sunday. The speech was part of America's Freedom Festival at Provo which is an annual patriotic gathering held around Independence Day to promote American values of faith, freedom, patriotism, and family.
He appeared with Elder Quentin L. Cook of the Quorum of the Twelve Apostles of the Mormon faith, at Sunday's event. On Monday Dolan met with church President Russell M. Nelson who presented him a statue of the Christus.
The Cardinal has previously worked with Mormon leaders on matters of religious freedom, faith, marriage and humanitarian efforts, including a 2017 ecumenical meeting in New York City with Mormon and Jewish leaders.
"To have us be able to work together on things that would bless this country," Cook said, "whether they're of a faith or no faith at all, has been an incredibly significant thing, as far as we're concerned."
Both Cardinal Dolan and Bishop Oscar Solis of the Diocese of Salt Lake City on Sunday emphasized that love of country should go together with love of God.
"We have to remember that patriotism is a biblical virtue," said Cardinal Dolan, adding that it is important "to see people coming together " especially to see our young people " to show that we're not alone in our love for God and country."
"We have to bring God and patriotism together. It's a great formula for a healthy society," said Bishop Solis.
"Religious liberty is very essential for us, and that it is defined as the First Amendment in this country, and that is why we need to safeguard and uphold, because this is a precious gift."
Bring down 'Iron curtain' of persecution, Religious Freedom Ministerial told Watch
U.S. leaders called for a worldwide "grassroots" movement to fight religious persecution at a global religious freedom gathering on ... continue reading
Pro-life women deliver semi-truck full of supplies, $72,000 to the border Watch
The heat index in McAllen, Texas was 125 degrees on Saturday, but that did not stop members of the pro-life movement from delivering a ... continue reading
Appeals court upholds injunction against contraception mandate exemption Watch
A federal appeals court on Friday unanimously blocked Department of Health and Human Services rules that would have exempted employers who ... continue reading
Bishops denounce new asylum policy at U.S.-Mexico border Watch
The president of U.S. bishops' conference issued a statement on Tuesday condemning a newly-announced rule on asylum eligibility at the ... continue reading
Orange diocese to dedicate Christ Cathedral Watch
The Diocese of Orange will dedicate its Christ Cathedral July 17 after a seven-year, $77-million renovation process. Orange, Calif. (CNA) - ... continue reading
pictures of saints
Prayers - The Good Morning God Prayer
The Good Morning God Prayer
St. Patrick (High School)
Explore the Bible - The Breastplate of Judgement


Without women, life is not as interesting as it seems, that is why women's healthcare should be something taken seriously. There seems to a common trend in places that miss out on their women's healthcare, and that is they are not living up to their potential. These are some of the reasons why more efforts are being made to creating these women's healthcare centers. Currently, there are increasing numbers of women's healthcare centers the world has to offer. These centers are equipped with the right medical tools and equipment as well as the best OBGYN specialists and medical doctors. Whatever your current location is, you just have to remember that you may be surrounded by women's healthcare centers around you. There are some things that you need to remember when you are going to be choosing between these centers. If you are planning to find a competent OBGYN specialist, below are some essential considerations in finding a women's healthcare center for your particular needs.
The best first move that you can make in finding the most fitting women's healthcare center for you is to do some research. In doing some research work, you can better figure out which centers you should explore and which ones you should ignore. A lot of women's healthcare centers have their own sites. It would be best to expand your research and look at each of their websites to learn more about them and their services. To even make your decision more sure, you should be able to read some feedback and reviews posted about the women's healthcare centers you are thinking of getting services from.
Another important consideration will be the fees and costs that you will be paying from the services that you get in these women's healthcare centers. You can say that the prices of the services that will be given to you will matter on a number of things. One way for you to determine that you are getting what you will be paying for is to compare the prices of services of each women's healthcare center that you are considering.
Another crucial consideration in picking out the best women's healthcare center for you is to check the credentials of their doctors, staff, and nurses. The best medical doctors often do not work in only one center but more. Being the patient, you are given the liberty to determine which among the medical doctors or OBGYN specialists from the women's healthcare center you wish to get services from. You may prefer a female OBGYN specialist and that is perfectly fine. At the end of the day, you just have to remember that no matter which medical doctors appeal to you from the women's healthcare center, you should be sure that they can really take care of you.


A natural age-defying eye cream that minimizes visible signs of aging and fatigue.
This age-defying eye treatment helps minimize the appearance of fine lines wrinkles and visibly reduce puffiness and dark shadows for awakened, younger-looking eyes. This eye cream also helps deliver hydration and lock in moisture around the eye area, while vitamin C from date palm extract enhances skin barrier protection. Helichrysum essential oil lends a green floral scent.
100 percent of the total ingredients in this product are from natural origin and 66 percent of the total ingredients are from organic farming. This product is vegan and free from toxins, fillers, artificial colors, artificial fragrances, all synthetic chemicals, and GMOs.
-For best results, apply around the entire eye area—upper and lower lids.
-Buckwheat Wax and Arnica: Help reduce eye area puffiness to diminish the look of under-eye puffiness.
-Helichrysm Essential Oil: Contains powerful toning and regenerating qualities.
-Date Palm Extract: Enhances barrier protection for healthier looking skin.


text:
Design for Children TR
by Lil'Gaea in Basın, Genel
Find our Iconic Doglite, Milky Desk and Dogbox amongst other clever designs from contemporary superstars including Philippe Starck, Nendo, Marc Newson, Piero Lissoni, Kengo Kuma, and Marcel Wanders.
"All designed objects are propaganda for a way of life", Alain de Botton once said. It's with these words that Kimberlie Birks, a New York-based art and design writer, opens the playfully poignant volume from Phaidon, Design for Children.
The publication comes not only as a catalog of over 450 objects for kids that have made design history, but also a compendium revealing how generations of the past were raised.
"Children's objects are often a signal of the times", says Birks in an interview with Fatherly, "reflecting both the evolution of the design industry and shifts in public perception".
And so, the Phaidon book becomes a sort of retrospection of design history, retracing the progression of technological advancements to revolutionize the practice: "from the wood and tubular steel constructions of the Bauhaus in the 1920s, to the plastic pioneers of the 1960s".
Our Royal Baby TR
Junior Design Awards 2019