package affectors;

import main.Node;
import main.Globals;

/** Placeholder affector for use with creating dummy (i.e. nonused) parameters.
 * Ingeneue throws a fit if there are parameters that are not used.
 * Put this in a cytoplasmic node, else you're going to be calling this more times
 * than you need to.
 *
 * <p> <b>Formula</b>
 * <br>dnodex/dt = 0
 *
 * <p> <b>Parameters</b>
 * <table width="500" border="1">
 * <tr><td width="150"> param </td><td> Dummy parameter </td></tr>
 * </table>
 *
 * <p> <b>Usage</b>
 * <code><font size = "3"><br>&nodex<blockquote>   &PlaceHolderAff  Dummy
 * </blockquote>
 * &endnodex</code></font>
 *
 * @author Kerry Kim
 * @version
*/


public class PlaceHolderAff extends Affector {
	int		firstParameter;
	/* And replace this comment with a description of the second parameter, if there is one.*/
	/* These next few lines give short descriptions of the Affector, the nodes used by
		the Affector, and the parameters used by the Affector. These descriptions are
		used by Ingeneue's interface to guide users in constructing models with a point
		and click interface - something that is currently not possible, but which we
		hope will be available within a year. */
	/* This first string is a several word description of what the Affector does. */
	static final String		affectorDescription = "For creating dummy parameters";
	/* This list of strings describes, in one or a few words, the purpose of each node
		used by the Affector. Note that it is important to put the correct number of
		strings here, one per node, as the number of strings tells code which inputs
		a network file how many nodes it should be expecting.
		If the Affector uses no nodes, set nodeDescriptions = null. */
	static final String	[]	nodeDescriptions = {};
	/* This list of strings describes, in one or a few words, the purpose of each
		parameter used by the Affector. As with the node descriptions, it is important
		to get the right number of strings even if you don't put in the effort to make
		good descriptions. If there are no parameters, set paramDescriptions = null. */
	static final String	[]	paramDescriptions = {"Dummy parameter"};

	/* This list of integers specifies whether each Node used by the Affector is in the
		same cell as the Affectors Node, or is a neighboring cell. Put -1 for Nodes in
		the same cell, 1 for Nodes in neighboring cells. The numbers here correspond to
		the descriptions in nodeDescriptions above. */
	static final int	[]	whichSides = {};

	/** Constructor for this Affector. All Affectors must use a no-argument constructor, and
		currently there is no need to do anything in the constructor of most Affectors.
		You do need to change the name here from TemplateAff to [YourAffectorsName]Aff. */
	public PlaceHolderAff()	{}

	/* Tells the rest of Ingeneue about this Affector. See the tutorial for the meaning
		of each line. */
	protected void setLabelsAndTypes()	{
		/* This function tells the rest of Ingeneue the descriptions of the Affector
			and each node and parameter used by the Affector. If there are no Nodes
			used by the Affector you can pass null in place of nodeDescriptions and
			similarly for paramDescriptions if there are no parameters. */
		setDescriptions(affectorDescription, nodeDescriptions, paramDescriptions);
		
		/* This tells the rest of Ingeneue whether this Affector is supposed to
			operate on Nodes that reside in the membrane. The default is that
			an Affector operates only on cytoplasmic Nodes, or if it operates on
			membrane Nodes then it only operates on the sum of the concentrations
			across all faces of the cell. In either of these cases, you can just
			delete this method call. Otherwise, you need to pass true as the first
			argument (indicating that Affector operates on membrane Nodes) and the
			sides of each Node as the second argument (see comment near whichSides above). */
		setSided(true, whichSides);

		/* This tells the rest of Ingeneue whether the Affector uses the concentration
			of the Node whose value it is helping determine. For instance, a Decay
			Affector calculates its value based on the concentration of the Node it
			is decaying. On the other hand, a translation Affector produces the same
			amount of protein regardless of the concentration of the protein. In the first
			of these cases, you need to inform the rest of Ingeneue that the formula uses
			the concentration of the target Node. In the latter, you must inform Ingeneue
			that it doesn't. The default is to assume that the Affector doesn't use the
			target Node's concentration, so in that case you can just delete this method
			call. */
		setContainsTarget(true);

		/* These four flags tell the rest of Ingeneue some characteristics of
			the Affector. ... and george, you have to remind me what they do. */
		this.Type[GUI_CAPABLE] = 1;
		this.Type[CERTIFICATION] = Affector.RETURNS_DERIV;
		this.Type[MATHTYPE] = Affector.CC;
		this.Type[TERMTYPE] = Affector.PRODUCTION;
	}
	
	/*  This is where the rest of Ingeneue gives this Affector indices to each parameter
		that it uses. You should  make a line for each parameter in the same order as
		they are described in paramDescriptions above, and then assign the values from param_nums
		as shown in the example below. */
	public void setParameterNumbers(int [] param_nums)
	{
		firstParameter = param_nums[0];
	}
	
	/* This is the formula for this Affector.*/
	public float getValue(Node which_node)	{
		return 0;
	}
}