//
// The AcCoRD Simulator
// (Actor-based Communication via Reaction-Diffusion)
//
// Copyright 2016 Adam Noel. All rights reserved.
// 
// For license details, read LICENSE.txt in the root AcCoRD directory
// For user documentation, read README.txt in the root AcCoRD directory
//
// HOWTO_READ_CONFIG.txt - explains how to define simulation inputs
//
// Last revised for AcCoRD v1.0 (2016-10-31)
//
// Revision history:
//
// Revision v1.0 (2016-10-31)
// - added "Burst" modulation, which does not modulate binary data but always
// releases molecules. Can release multiple types of molecules
// - added local diffusion coefficients defined for individual regions
// - added local diffusion coefficient to apply specifically to calculate a
// surface interaction reaction probability
// - changed convention for defining region anchor coordinates and the number of
// subvolumes along each dimension of rectangular regions. Old convention is still
// supported
//
// Revision v0.6 (2016-05-30)
// - added new properties for bimolecular reactions in microscopic regime
// - added new options for active actors, which can now be points and have
// constant data sequences
// - added option for choice of hybrid transition algorithm
//
// Revision v0.5.1 (2016-05-06)
// - describe new properties for chemical reactions (particularly surface reactions)
//
// Revision v0.5 (2016-04-15)
// - noted importance of passive actor time step shifts from microscopic time steps
//
// Revision v0.4.1
// - made placement of config file and output more flexible
//
// Revision v0.4
// - added parameters for sphere regions and actors
// - added ability to choose what regions a chemical reaction can occur in
//
// Revision v0.3.1.1
// - added comment that a child region must be fully defined within the boundary of its parent
//
// Revision v0.3.1
// - header added
// - added "Warning Override" member to main object
//
// WARNING: THIS IS NOT A REAL CONFIGURATION FILE!!!
// THE "COMMENTS" IN THIS FILE MAKE IT INVALID JSON!
// BUT ... THIS FILE DESCRIBES HOW TO WRITE A VALID CONFIGURATION FILE
//
// With that out of the way, welcome to this "tutorial" for preparing proper
// AcCoRD configuration files.
//
// This document is current as of v1.0 (2016-10-31).
//
// Please note that valid configuration files cannot have these comments
// preceded by "//". If you remove these comments and place a copy of
// this file where AcCoRD can "see" it, then you can (try to) run it in AcCoRD.
// It probably won't work because this file provides an exhaustive list of
// configuration options and many of them contradict each other.
// However, the repository config folder includes
// a number of sample valid configuration files.
// AcCoRD looks for config files first in the current directory, then
// in a "config" subdirectory, then in a "../config/" directory.
// Please refer to README.txt for instructions on running a simulation.
//
// AcCoRD input and summary output files use the JSON format. JSON stands for
// JavaScript Object Notation and it is defined at json.org.
// JSON is a way of organizing data into an object.
//
// AcCoRD requires that names (i.e., the words between double quotes
// and before a colon, e.g., "Output Filename") MUST be written EXACTLY as they are
// in this file. These names are hard-coded into AcCoRD.
//
// Most names are mandatory in a configuration file, though some of them may have
// an empty value associated with them. In particular, "Chemical Reaction Specification"
// is an empty array if there are no chemical reactions to simulate.
//
// The ORDER of name/value pairs does not matter for it to be parsed correctly,
// but the NESTING does. So, for example, you can swap the order of "Output Filename"
// and "Simulation Control", but "Number of Repeats" must be defined inside the
// "Simulation Control" object.
//
// An object is encapsulated inside curly braces {}. A configuration file has one top-level
// object and a number of nested objects. An array is encapsulated inside square brackets [].
// The items in an object are name/value pairs, but the items in an array do not have
// associated names. Items are separated with commas.
//
// Extra white spaces are ignored.
//
// Read below to see a description of the individual parameters

{
	"Notes": "This field replaces commenting.",
	// The "Notes" item is a way to include comments.
	// Its contents are ignored by parsing.
	// In fact, you can add any other additional fields to a configuration file
	// and they will be ignored as long as they are formatted correctly
												
	"Output Filename": "sample.txt", 
	// the name of the simulation output file that will
	// be placed in the "results" directory with "_SEEDXX" appended before
	// .txt, where XX is the random number seed for the simulation. Simulation
	// meta-data and other information for reading the
	// output file will be written to summary_sample_output_SEEDXX.txt
											
	"Warning Override": false,
	// By default, a simulation will pause if it encounters
	// any warnings while trying to read the configuration file.
	// To ignore any warnings and continue the simulation automatically,
	// then set this parameter to true.
	
	"Simulation Control": {
	// The primary top-level simulation parameters
	
		"Number of Repeats": 2, 	
		// The number of independent realizations/runs
		// to execute in the simulation. Will be converted to an integer.
									
		"Final Simulation Time": 1e-2,
		// Simulation will stop once this time is surpassed
		// Units are seconds.
		
		"Global Microscopic Time Step": 1e-4,
		// All microscopic regions use a single common time step (for now)
		// Units are seconds.
		
		"Random Number Seed": 1,
		// Seed value for the random number generator (RNG). Will be converted to an integer.
		// This seed is over-written if the user defines one at runtime!
		// AcCoRD uses the Mersenne twister RNG; this seed number is added to the twister's
		// default seed.
		// Generally, a seed value initializes a RNG. Running the same
		// simulation twice with the same random number seed will produce identical results
		// in the corresponding realizations (i.e., the first realization in each output file
		// will be the same, and the second realization in each output file will be the same, etc).
		// AcCoRD uses explicit seeds (instead of random seeds) for 2 reasons:
		// 1) all results are re-producable
		// 2) by specifying different seeds for different executions of the same simulation,
		// the simulations can be executed on different machines and the output files aggregated
		// without needing to worry about the simulations having the same output.
		
		"Max Number of Progress Updates": 100,
		// Control the maximum number of updates
		// to display in the console. There will be no more
		// than one update per realization. Will be converted to an integer.
		
		"Small Subvolumes at Hybrid Interface?": true,
		// Choice of transition algorithm at hybrid interfaces (i.e., where a microscopic
		// region is adjacent to a mesoscopic region). The small time step / large subvolume
		// algorithm and large time step / small subvolume algorithm are described in
		// Flegg et al., "Analysis of the two-regime method on square meshes", SIAM Journal
		// of Scientific Computing, vol. 36, no. 3, pp. 561--588, 2014.
		// Warning will appear if setting is defined when there isn't both a microscopic
		// region and mesoscopic region defined, or not defined when there is. Default is true.
		// Small subvolume assumption is more accurate when characteristic diffusion distance
		// in microscopic regime is comparable to the mesoscopic subvolume size.
		
		"Max Intrastep Micro to Meso Distance": 10e-6
		// Microscopic molecules that are at least this distance from closest mesoscopic surface
		// either before or after diffusion step are not considered to have entered mesoscopic
		// regime with significant probability during diffusion step.
	},
	"Chemical Properties": {
	// Describes the molecules in the system and how they interact
	
		"Number of Molecule Types": 1,
		// Number of distinct types of molecules. A reaction intermediate would count as one new type
		// Will be converted to an integer.
		
		"Diffusion Coefficients": [1e-9],
		// An array of length "Number of Molecule Types". Units are metre^2/second
		
		"Chemical Reaction Specification": [
		// Array of chemical reactions in the environment. No reactions are required (can leave array empty)
			{									
			// First (and only) chemical reaction. This one is actually meaningless because no
			// reactants or products are defined. See sample configurations for actual reactions
			
				"Notes": "",
				
				"Label": "Reaction 1",
				// The reaction's label is an optional ID that is only needed
				// if reaction is reversible and we need to indicate which reaction
				// is coupled to which
				
				"Is Reaction Reversible?": false,
				// Reversibility influences how reaction probabilities are calculated
				// when steady state calculations are used for surface reactions
				
				"Reverse Reaction Label": "Reaction 2",
				// Label of the reverse reaction. Only define if reaction is reversible.
				// Reversibility influences how reaction probabilities are calculated
				// when steady state calculations are used for surface reactions.
				// If 2 reactions are coupled, then each must list the other as its
				// reverse in order for these reaction probabilities to be determined
				// correctly.
				
				"Surface Reaction?": false,
				// A chemical reaction can either occur in "normal" regions or in "surface regions"
				
				"Surface Reaction Type": "Normal",
				// Type of surface reaction. Only checked if "Surface Reaction?" is true.
				// Implemented values are "Normal", "Absorbing", "Desorbing",
				// "Membrane Inner", and "Membrane Outer".
				// If reaction is not "Normal", then it should be first order and
				// it should be the only reaction associated with the reactant
				// in the surface regions where it is active.
				
				// If a reaction is "Membrane Inner" or "Membrane Outer", then it should
				// only be assigned to regions that are membranes, and no product
				// molecules should be specified. The "Membrane Inner" reaction is
				// for molecules that transition from the side of the membrane where
				// the surface is considered to be "Inner" to the region, i.e., 2D
				// surfaces that are to the left, down, or in directions relative to
				// the normal region, OR if the surface is the normal region's parent.
				// Analogously, the "Membrane Outer" reaction is for molecules that
				// transition from a normal region through a surface that is to the
				// right, up, or out directions relative to the normal region, OR
				// if the the surface is the normal region's child.
				
				// If a reaction is "Absorbing" or "Desorbing", then it should only be
				// assigned to surface regions that aren't membranes. These reactions
				// are needed for molecules to be transfered to/from a surface region
				// from a normal region. Note that an absorbed molecules will diffuse
				// even if it is "absorbed", and this can be avoided by setting a
				// different molecule type (with 0 diffusion coefficient) as the
				// product of the absorbing reaction
				
				"Surface Reaction Diffusion Coefficient": 1e-9,
				// Optional property to over-ride the default diffusion coefficient
				// for a surface reaction. By default, the coefficient used is the
				// default (i.e., global) diffusion coefficient
				// of the reactant for an absorbing reaction or membrane transition,
				// and that of the first product for a desorption reaction.
				
				"Surface Transition Probability": "Normal",
				// Selection for algorithm for how a surface transition probability
				// is calculated. Neeed for "Absorbing", "Desorbing", "Membrane
				// Inner", and "Membrane Outer" reactions. Values are "Normal",
				// "Mixed", and "Steady State". "Normal" treats the reaction as a
				// regular 1st order reaction. "Mixed" gives the transition probability
				// assuming that the system is in the well-mixed state. "Steady state"
				// assumes that the system is in the steady state, but has been shown
				// to be accurate for transient states as well. The "Steady State"
				// probabilties were derived under the assumption that the surface is
				// flat and the system is 1-dimensional. Derivations are in S.S.
				// Andrews, "Accurate particle-based simulation of adsorption,
				// desorption and partial transmission" Physical Biology, vol. 6,
				// p.046015, 2009.
				
				"Default Everywhere?": true,
				// A chemical reaction can by default take place everywhere or nowhere.
				// This applies either to all "normal" regions or all "surface" regions,
				// depending on "Surface Reaction?".
				// Exceptions to this general setting are defined by "Exception Regions"
												
				"Exception Regions": [],
				// An array of strings of region "Label"s that are exceptions to the
				// setting of "Default Everywhere?"
				
				"Reactants": [0],
				// An array of length "Number of Molecule Types". Indicates how many of each type of molecule are
				// reactants. THERE MUST BE NO MORE THAN TWO REACTANTS, AND NO MORE THAN ONE
				// REACTANT IF THE REACTION IS A SURFACE REACTION THAT IS NOT NORMAL
				// Will be converted to integers.
												
				"Products": [0],
				// An array of length "Number of Molecule Types". Indicates how many of each
				// type of molecule are products. There is no limit to the number of products.
				// Will be converted to integers.
				// Non-zero values are ignored for membrane reactions.
				
				"Products Released?": [false],
				// Boolean array of length "Number of Molecule Types". Defined for
				// non-membrane surface reactions. Indicates whether products are
				// detached from the surface.
				
				"Release Placement Type": "Leave",
				// Define how molecules are placed if they are released from a surface.
				// Defined only if at least one value in the "Products Released?"
				// array is true. Values are "Leave", "Full Diffusion", and "Steady
				// State Diffusion". For "Leave", molecules are left at the surface
				// and can diffuse/react as normal in the remainder of the time slot.
				// For "Full Diffusion" and "Steady State Diffusion", molecules are
				// forcibly placed some distance away from the surface and left there
				// until the end of the time slot. "Full Diffusion" assumes regular 1D
				// diffusion away from a reflective surface. "Steady State Diffusion"
				// assumes system is at steady state and determines distance based
				// on that calculated in
				// S.S. Andrews, "Accurate particle-based simulation of adsorption,
				// desorption and partial transmission" Physical Biology, vol. 6,
				// p.046015, 2009.
												
				"Reaction Rate": 1,
				// Chemical reaction rate. Units depend on the order of the reaction.
				// To have an "infinite" reaction rate (e.g., for perfect absorption),
				// set to 1e9999.
				
				"Binding Radius": 1e-6,
				// Microscopic reactants that are separated by less than this distance
				// after diffusion step will react if reaction is 2nd order. A reaction
				// site is determined based on the reactant's diffusion coefficients.
				// Reaction will be cancelled if either reactant's path to the reaction
				// site is impeded (i.e., via a region surface). Molecules will only be
				// compared with molecules in the same region or neighboring regions
				// where the same reaction can occur. The region of the reaction site
				// must also allow the reaction
				
				"Unbinding Radius": 5e-6
				// Separation distance applied to bimolecular reactions in microscopic
				// regime with more than 1 product. Ignored if there are 1 or 0 products.
				// If there are 2 products, then they are separated according to this
				// distance along the line joining the locations of the 2 reactants
				// at the end of diffusion step. If there are more than 2 products,
				// then each is placed in a random direction but the sum of the distances
				// of the products from the reaction site is this value. Transition of 
				// each product is verified as needed (could be reflected or react with
				// a surface)
			}
		]
	},
	"Environment":	{
	// Describes the physical dimensions of the simulation space and the actors inside it
		
		"Subvolume Base Size": 1e-6,
		// Environment is defined by a set of regions. Each region, whether microscopic
		// or mesoscopic, is measured by number of square/cubic subvolumes in the region. This
		// base size is used to scale ALL Rectangular subvolumes in the environment (every subvolume
		// in a rectangular region has a size that is an integer multiple of the base size)
		// Units are meters. This base size is also used when determining margin of error
		// for improperly-overlapping regions, so it should still be assigned a "small" value
		// when only spherical regions are defined.
										
		"Region Specification": [
		// Array of regions in the environment. There must be at least ONE region
			{
			// Object describing the first region
			
				"Notes": "",
				// Another "Notes" item that is ignored
				// In fact, you can add any other additional fields to a configuration file
				// and they will be ignored as long as they are formatted correctly
			
				"Label": "A",
				// The region's label is an optional ID that is only needed
				// if another region is nested within this region and so is
				// its parent
			
				"Parent label": "",
				// The ID of this region's parent region, indicating
				// that this region is placed inside that parent. It is
				// possible to have multiple levels of nesting, in which
				// case each nested region must indicate the region directly
				// "above" it as its own parent. A child region must be fully
				// defined within the boundary of its parent (i.e., no protrusions
				// are permitted).
				
				"Local Diffusion Coefficients": [1e-9],
				// Over-ride the global diffusion coefficients in this region.
				// An array of length "Number of Molecule Types". Units are metre^2/second
				
				"Shape": "Rectangular Box",
				// Shape of the region. CURRENTLY "Rectangular Box", "Sphere", and
				// "Rectangle" ARE SUPPORTED
				
				"Type": "Normal",
				// Type of region. CURRENTLY "Normal", "3D Surface", and "2D Surface"
				// ARE SUPPORTED. 3D (2D) surface regions must be on the boundary of normal
				// 3D (2D) regions.
				
				"Surface Type": "Outer",
				// Type of surface region. Only define if "Type" is "3D Surface" or
				// "2D Surface". Possible values are "Outer", "Inner", and "Membrane".
				// "Outer" and "Inner" surfaces are one-sided and specify what side
				// they interact with. Such a surface must be fully covered by neighboring
				// regions on its active side. If "Outer", then the active side faces its lower
				// x/y/z, or the entire "outside" if the surface is of the same dimension as
				// the regions that it is a surface to (e.g., if a 3D surface is a 3D box, then
				// the "Outer" faces are all outward faces on the box).
				// "Membrane" surfaces are double-sided, and need first order reactions
				// to define whether individual molecules can pass through them. A membrane
				// surface must be fully covered by normal neoghboring regions on both sides.
				
				"Anchor Coordinate": [0, 0, 0],
				// OPTION 1 for defining a region's anchor coordinate.
				// The anchor coordinate defines the relative position of the region
				// in GLOBAL space (and NOT relative to its parent if it has one).
				// Must be a vector of length 3.
				// Rectangular regions are defined as rectangular boxes whose faces are parallel to the
				// global coordinate axes.
				// The anchor of a rectangular box region is the "minimum coordinate" of the
				// region, i.e., (xmin, ymin, zmin). Consider the value of
				// "Subvolume Base Size" when setting the anchor points of rectangular box regions.
				// The anchor of a sphere region is its center.
				// All units are meters.
				
				"Anchor X Coordinate": 0,									
				"Anchor Y Coordinate": 0,
				"Anchor Z Coordinate": 0,
				// OPTION 2 for defining a region's anchor coordinate. Same meaning as
				// "Anchor Coordinate" above, but defined using 3 different parameters
				// (one for each dimension)
				// This method was the original convention and could be deprecated in
				// a future release.
								
				//
				//!!!!  The following parameters apply to Rectangular Box regions ONLY !!!!
				// AcCoRD will produce warnings if any of these parameters are defined for a
				// spherical region
				//
				
				"Integer Subvolume Size": 2,
				// The size of the side of one subvolume in this region, which is scaled by
				// "Subvolume Base Size"
												
				"Is Region Microscopic?": false,
				// If true, all molecules in the region are individually tracked.
				// If false, then the region is mesoscopic and the subvolumes are used as
				// virtual containers.
				// Sphere regions do not need this defined because they are always microscopic.
				// Note that subvolumes in mesoscopic regions that are adjacent to microscopic
				// regions must share the entire subvolume face with the adjacent microscopic
				// region. This is due to how adjacency is detected and how molecules are placed
				// when leaving the mesoscopic regime.
				
				"Number of Subvolumes Per Dimension": [10, 5, 5]"
				// OPTION 1 for defining a rectangular region's dimensions
				// Size of the region along each axis as measured by the subvolumes in
				// that region. Sphere regions does not need this defined because they
				// always have one subvolume.
				// Must be a vector of length 3.
													
				"Number of Subvolumes Along X": 10,
				"Number of Subvolumes Along Y": 5,
				"Number of Subvolumes Along Z": 5
				// OPTION 2 for defining a rectangular region's dimensions.
				// Same meaning as "Number of Subvolumes Per Dimension" above,
				// but defined using 3 different parameters (one for each dimension)
			},
			{							
			// Object describing the second region. Only one region must be described
				"Notes": "",			
				"Label": "B",
				// Optional ID			
				"Parent label": "",
				"Shape": "Rectangular Box",
				"Type": "Normal",
				
				"Anchor Coordinate": [20e-6, 0, 0],
				// Note that here the second region is placed so that it is to the "right" of region 1.
				
				"Integer Subvolume Size": 1,
				"Is Region Microscopic?": true,
				"Number of Subvolumes Per Dimension": [10, 10, 10]"
			},
			{							
			// Object describing the third region. Only one region is necessary
			// This region is spherical in order to show the different properties that are used
				"Notes": "",			
				"Label": "C",
				// Optional ID			
				"Parent label": "B",
				"Shape": "Sphere",
				"Type": "Normal",
				
				"Anchor Coordinate": [25e-6, 5e-6, 5e-6],
				
				"Radius": 4e-6
				// Radius of the sphere. This region is inside of a rectuangular box region
				// so its surface must have a clearance equal to the subvolume size of the
				// rectangular region.
				// Generally, a sphere region can be infinite in size by specifying a radius
				// large enough to overflow a double (e.g., 1e9999 will work)
				// Units are meters
			}
		],
		"Actor Specification": [
		// Array of actors in the environment. No actors are required, but not much will happen if there
		// aren't any (chemical reactions can still generate molecules that can then diffuse
		// and react). Active actors are used to "manually" add molecules, and passive actors are needed
		// to observe molecules for simulation output.
			{
			// Object describing the first actor
			
				"Notes": "",
				
				"Is Actor Location Defined by Regions?": false,
				// Declare how the actor's shape is defined. If true, then "List of Regions
				// Defining Location" is needed. If false, then the shape and its boundary
				// must be specified.
				
				"List of Regions Defining Location": [],
				// Only define if "Is Actor Location Defined by Regions?" is true. List the
				// labels of regions whose union form the space occupied by this actor.
				
				"Shape": "Rectangular Box",
				// Only define if "Is Actor Location Defined by Regions?" is false.
				// Shape of the actor. CURRENTLY "Rectangular Box", "Sphere", and
				// "Rectangle" ARE SUPPORTED. Active actors can also have "Point".
				
				"Outer Boundary": [0, 20e-6, 0, 10e-6, 0, 10e-6],
				// Only define if "Is Actor Location Defined by Regions?" is false.
				// The coordinates of the actor. For a "Rectangular Box" actor, the format is
				// [x min, x max, y min, y max, z min, z max].
				// For a "Sphere" actor, the format is [x center, y center, z center, radius].
				// For a "Point" actor, the format is [x, y, z].
				// Consider the size and location of the regions carefully when defining where
				// to place actors. The outer boundary of a spherical actor can only intersect
				// microscopic regions but no region boundaries. Mesoscopic regions can be inside
				// of a spherical actor only if they are fully within the actor.
				// Spherical actors can have an "infinite" radius by setting a value large enough
				// to overflow double (e.g., 1e9999 works)
				// This actor fully overlaps region 1.
				// Active actors should be defined in space where there are regions
				// Passive actors can be defined anywhere.
				// Actors can overlap with any number of regions and also with each other
				// Units are meters.
														
				"Is Actor Active?": true,
				// If true, actor releases molecules. If false, actor counts them.
				
				"Start Time": 0,
				// Time of actor's first action.
				// There should be a slight "offset" for passive actors that are synched
				// to the actions of active actors OR to microscopic time steps.
				// If molecules are being both added and
				// counted at the same instant, and/or a microscopic step is executed,
				// no guarantee is made about which order the actions will occur
				// Units are seconds.
															
				"Is There Max Number of Actions?": false,
				// A maximum number of actions can be called to "turn of" an actor before the
				// final time is reached.
				
				"Max Number of Actions": 100,
				// Number of actions performed if "Is There Max Number of Actions?" is true
				
				"Is Actor Independent?": true,
				// If true, actions are started at pre-defined intervals.
				// CURRENTLY IGNORED. DEPENDENT ACTORS ARE NOT YET IMPLEMENTED,
				// SO ALL ACTORS ARE INDEPENDENT
															
				"Action Interval": 5e-3,
				// The action interval defines how often a new action is initiated by the actor
				// If the actor is active, then it might begin a new release of molecules.
				// If the actor is passive, then molecules within the actor will be immediately
				// counted.
				// Units are seconds.
				
				"Is Actor Activity Recorded?": true,
				// If true, actor data will be written to the output file.
				
				//
				//!!!!  The remaining parameters apply to ACTIVE actors ONLY !!!!
				//
				
				"Random Number of Molecules?": false,
				// If true, the actual number of molecules released will be random but will have
				// expected value determined from "Modulation Strength"
				// If false, a deterministic number of molecules are released for a given symbol.
															
				"Random Molecule Release Times?": false,
				// If true, AND if "Random Number of Molecules?" is true, then the individual
				// molecule release times are a random process.
				// If false, then molecules are released uniformly over the release interval in slots.
															
				"Release Interval": 0,
				// Time over which one action's worth of molecules are released. Analogous to pulse width.
				// Units are seconds.
				
				"Slot Interval": 0,
				// If "Random Molecule Release Times?" is false, then molecules of a single pulse 
				// are released at this interval
				// Units are seconds.
															
				"Bits Random?": true,
				// If true, then the underlying actor bit stream can have 1s or 0s.
				// If false, then "Bit Sequence" must be defined.
				// Should not be defined if "Modulation Scheme" is "Burst".
				
				"Bit Sequence": [0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1],
				// Constant bit sequence used if "Bits Random?" is false
															
				"Probability of Bit 1": 1,
				// If "Bits Random?" is true, then this is the probability that a given bit will be 1.
				// Should not be defined if "Modulation Scheme" is "Burst".
				
				"Modulation Scheme": "CSK",
				// The actor's modulation scheme. Current options are:
				// "CSK" - concentration shift keying
				// "Burst" - like CSK for 1 bit that always has value 1, but can
				//		also release multiple types of molecules.
				
				"Modulation Bits": 1,
				// Integer number of bits in one symbol
				// Should not be defined if "Modulation Scheme" is "Burst".
				
				"Modulation Strength": 10,
				// Used to scale number of molecules released. Not necessarily the number of molecules per
				// bit.
				// If modulation is "CSK" and "Release Interval" is greater than zero, the modulation
				// 		strength defines the release rate (constant number of molecules per slot
				//		interval if "Random Molecule Release Times?" is false, and a chemical generation
				//		rate if "Random Molecule Release Times?" is true). For example, if modulation is 
				//		"CSK", "Modulation Bits" is 2, and "Random Molecule Release Times?" is false, then
				//		the actor will release val*"Modulation Strength" molecules in each slot, where
				//		val is the current symbol (a random integer between 0 and 3). If "Random Molecule
				// 		Release Times?" is true and modulation is "CSK", then this defines the number of
				//		molecules released per second if there is one modulation bit and the current bit is 1.
				// If modulation is "CSK", then only the first true value in "Is Molecule Type Released?"
				// 		will be transmitted (the remaining values are ignored)
				// If "Modulation Scheme" is "Burst", then "Modulation Strength" is applied the same as for
				// 		"CSK" where "Modulation Bits" is 1, and every type of molecule designated by
				// 		"Is Molecule Type Released?" array is released.
															
				"Is Molecule Type Released?": [true],
				// An array of length "Number of Molecule Types". Used to indicate which types of
				// molecules are released by this actor.
				// If "Modulation Scheme" is "CSK", then only the FIRST true will be recognized
				// If "Modulation Scheme" is "Burst", then multiple types of molecules can be released
		},
			{
			// Object describing the second actor
			// It is passive and overlaps region 2.
			
				"Notes": "",
				"Is Actor Location Defined by Regions?": false,
				"Shape": "Rectangle",	
				"Outer Boundary": [20e-6, 30e-6, 0, 10e-6, 0, 10e-6], 														
				"Is Actor Active?": false,				
				"Start Time": 1e-6,																		
				"Is There Max Number of Actions?": false,	
				"Max Number of Actions": 100,
				"Is Actor Independent?": true,				
				"Action Interval": 1e-3,
				
				//
				//!!!!  The remaining parameters apply to PASSIVE actors ONLY !!!!
				//
															
				"Is Time Recorded with Activity?": false,
				// If true, there will be an array of observation times written with each realization
				
				"Is Molecule Type Observed?": [true],
				// An array of length "Number of Molecule Types". Used to indicate which types of
				// molecules are counted by this actor.
																														
				"Is Molecule Position Observed?": [true]
				// An array of length "Number of Molecule Types". Used to indicate whether
				// the location of each individual molecule is written to output. Only applies
				// if "Is Molecule Type Observed?" for the same molecule type is also true.
		},
			{
			// Object describing the third actor
			// It is passive and overlaps region 1.
			// The overlap of region 1 ("B") is defined explicitly.
			
				"Notes": "",
				"Is Actor Location Defined by Regions?": true,
				"List of Regions Defining Location": ["B"],														
				"Is Actor Active?": false,				
				"Start Time": 1e-6,																
				"Is There Max Number of Actions?": false,	
				"Max Number of Actions": 100,
				"Is Actor Independent?": true,				
				"Action Interval": 1e-3,
				"Is Actor Activity Recorded?": true,		
				"Is Time Recorded with Activity?": true,	
				"Is Molecule Type Observed?": [true],																
				"Is Molecule Position Observed?": [false]
		}
		]		
	}
}