Example 11 with SimpleReaction
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class NetworkTransformer method transform.
private void transform(SimulationContext simContext, SimulationContext transformedSimulationContext, ArrayList<ModelEntityMapping> entityMappings, MathMappingCallback mathMappingCallback, NetworkGenerationRequirements networkGenerationRequirements) {
String msg = "Generating network: flattening...";
mathMappingCallback.setMessage(msg);
TaskCallbackMessage tcm = new TaskCallbackMessage(TaskCallbackStatus.Clean, "");
simContext.appendToConsole(tcm);
tcm = new TaskCallbackMessage(TaskCallbackStatus.TaskStart, msg);
simContext.appendToConsole(tcm);
long startTime = System.currentTimeMillis();
System.out.println("Convert to bngl, execute BNG, retrieve the results.");
try {
BNGOutputSpec outputSpec = generateNetwork(simContext, mathMappingCallback, networkGenerationRequirements);
if (mathMappingCallback.isInterrupted()) {
msg = "Canceled by user.";
tcm = new TaskCallbackMessage(TaskCallbackStatus.Error, msg);
simContext.appendToConsole(tcm);
throw new UserCancelException(msg);
}
long endTime = System.currentTimeMillis();
long elapsedTime = endTime - startTime;
System.out.println(" " + elapsedTime + " milliseconds");
Model model = transformedSimulationContext.getModel();
ReactionContext reactionContext = transformedSimulationContext.getReactionContext();
// ---- Parameters -----------------------------------------------------------------------------------------------
startTime = System.currentTimeMillis();
for (int i = 0; i < outputSpec.getBNGParams().length; i++) {
BNGParameter p = outputSpec.getBNGParams()[i];
// System.out.println(i+1 + ":\t\t"+ p.toString());
if (model.getRbmModelContainer().getParameter(p.getName()) != null) {
// if it's already there we don't try to add it again; this should be true for all of them!
continue;
}
String s = p.getName();
FakeSeedSpeciesInitialConditionsParameter fakeICParam = FakeSeedSpeciesInitialConditionsParameter.fromString(s);
if (speciesEquivalenceMap.containsKey(fakeICParam)) {
// we get rid of the fake parameters we use as keys
continue;
}
FakeReactionRuleRateParameter fakeKineticParam = FakeReactionRuleRateParameter.fromString(s);
if (fakeKineticParam != null) {
System.out.println("found fakeKineticParam " + fakeKineticParam.fakeParameterName);
// we get rid of the fake parameters we use as keys
continue;
}
throw new RuntimeException("unexpected parameter " + p.getName() + " in internal BNG processing");
// Expression exp = new Expression(p.getValue());
// exp.bindExpression(model.getRbmModelContainer().getSymbolTable());
// model.getRbmModelContainer().addParameter(p.getName(), exp, model.getUnitSystem().getInstance_TBD());
}
endTime = System.currentTimeMillis();
elapsedTime = endTime - startTime;
msg = "Adding " + outputSpec.getBNGParams().length + " parameters to model, " + elapsedTime + " ms";
System.out.println(msg);
// ---- Species ------------------------------------------------------------------------------------------------------------
mathMappingCallback.setMessage("generating network: adding species...");
mathMappingCallback.setProgressFraction(progressFractionQuota / 4.0f);
startTime = System.currentTimeMillis();
System.out.println("\nSpecies :");
// the reactions will need this map to recover the names of species knowing only the networkFileIndex
HashMap<Integer, String> speciesMap = new HashMap<Integer, String>();
LinkedHashMap<String, Species> sMap = new LinkedHashMap<String, Species>();
LinkedHashMap<String, SpeciesContext> scMap = new LinkedHashMap<String, SpeciesContext>();
LinkedHashMap<String, BNGSpecies> crossMap = new LinkedHashMap<String, BNGSpecies>();
List<SpeciesContext> noMapForThese = new ArrayList<SpeciesContext>();
// final int decimalTickCount = Math.max(outputSpec.getBNGSpecies().length/10, 1);
for (int i = 0; i < outputSpec.getBNGSpecies().length; i++) {
BNGSpecies s = outputSpec.getBNGSpecies()[i];
// System.out.println(i+1 + ":\t\t"+ s.toString());
String key = s.getConcentration().infix();
FakeSeedSpeciesInitialConditionsParameter fakeParam = FakeSeedSpeciesInitialConditionsParameter.fromString(key);
if (fakeParam != null) {
Pair<SpeciesContext, Expression> value = speciesEquivalenceMap.get(fakeParam);
// the species context of the original model
SpeciesContext originalsc = value.one;
Expression initial = value.two;
// replace the fake initial condition with the real one
s.setConcentration(initial);
// we'll have to find the species context from the cloned model which correspond to the original species
SpeciesContext sc = model.getSpeciesContext(originalsc.getName());
// System.out.println(sc.getName() + ", " + sc.getSpecies().getCommonName() + " ...is one of the original seed species.");
// existing name
speciesMap.put(s.getNetworkFileIndex(), sc.getName());
sMap.put(sc.getName(), sc.getSpecies());
scMap.put(sc.getName(), sc);
crossMap.put(sc.getName(), s);
noMapForThese.add(sc);
continue;
}
// all these species are new!
// generate unique name for the species
int count = 0;
String speciesName = null;
String nameRoot = "s";
String speciesPatternNameString = s.extractName();
while (true) {
speciesName = nameRoot + count;
if (Model.isNameUnused(speciesName, model) && !sMap.containsKey(speciesName) && !scMap.containsKey(speciesName)) {
break;
}
count++;
}
// newly created name
speciesMap.put(s.getNetworkFileIndex(), speciesName);
SpeciesContext speciesContext;
if (s.hasCompartment()) {
String speciesPatternCompartmentString = s.extractCompartment();
speciesContext = new SpeciesContext(new Species(speciesName, s.getName()), model.getStructure(speciesPatternCompartmentString), null);
} else {
speciesContext = new SpeciesContext(new Species(speciesName, s.getName()), model.getStructure(0), null);
}
speciesContext.setName(speciesName);
try {
if (speciesPatternNameString != null) {
SpeciesPattern sp = RbmUtils.parseSpeciesPattern(speciesPatternNameString, model);
speciesContext.setSpeciesPattern(sp);
}
} catch (ParseException e) {
e.printStackTrace();
throw new RuntimeException("Bad format for species pattern string: " + e.getMessage());
}
// speciesContext.setSpeciesPatternString(speciesPatternString);
// model.addSpecies(speciesContext.getSpecies());
// model.addSpeciesContext(speciesContext);
sMap.put(speciesName, speciesContext.getSpecies());
scMap.put(speciesName, speciesContext);
crossMap.put(speciesName, s);
// }
if (mathMappingCallback.isInterrupted()) {
msg = "Canceled by user.";
tcm = new TaskCallbackMessage(TaskCallbackStatus.Error, msg);
simContext.appendToConsole(tcm);
throw new UserCancelException(msg);
}
// if(i%50 == 0) {
// System.out.println(i+"");
// }
// if(i%decimalTickCount == 0) {
// int multiplier = i/decimalTickCount;
// float progress = progressFractionQuota/4.0f + progressFractionQuotaSpecies*multiplier;
// mathMappingCallback.setProgressFraction(progress);
// }
}
for (SpeciesContext sc1 : model.getSpeciesContexts()) {
boolean found = false;
for (Map.Entry<String, SpeciesContext> entry : scMap.entrySet()) {
SpeciesContext sc2 = entry.getValue();
if (sc1.getName().equals(sc2.getName())) {
found = true;
// System.out.println("found species context " + sc1.getName() + " of species " + sc1.getSpecies().getCommonName() + " // " + sc2.getSpecies().getCommonName());
break;
}
}
if (found == false) {
// we add to the map the species context and the species which exist in the model but which are not in the map yet
// the only ones in this situation should be plain species which were not given to bngl for flattening (they are flat already)
// System.out.println("species context " + sc1.getName() + " not found in the map. Adding it.");
scMap.put(sc1.getName(), sc1);
sMap.put(sc1.getName(), sc1.getSpecies());
noMapForThese.add(sc1);
}
}
for (Species s1 : model.getSpecies()) {
boolean found = false;
for (Map.Entry<String, Species> entry : sMap.entrySet()) {
Species s2 = entry.getValue();
if (s1.getCommonName().equals(s2.getCommonName())) {
found = true;
// System.out.println("found species " + s1.getCommonName());
break;
}
}
if (found == false) {
System.err.println("species " + s1.getCommonName() + " not found in the map!");
}
}
SpeciesContext[] sca = new SpeciesContext[scMap.size()];
scMap.values().toArray(sca);
Species[] sa = new HashSet<Species>(sMap.values()).toArray(new Species[0]);
model.setSpecies(sa);
model.setSpeciesContexts(sca);
boolean isSpatial = transformedSimulationContext.getGeometry().getDimension() > 0;
for (SpeciesContext sc : sca) {
if (noMapForThese.contains(sc)) {
continue;
}
SpeciesContextSpec scs = reactionContext.getSpeciesContextSpec(sc);
Parameter param = scs.getParameter(SpeciesContextSpec.ROLE_InitialConcentration);
BNGSpecies s = crossMap.get(sc.getName());
param.setExpression(s.getConcentration());
SpeciesContext origSpeciesContext = simContext.getModel().getSpeciesContext(s.getName());
if (origSpeciesContext != null) {
ModelEntityMapping em = new ModelEntityMapping(origSpeciesContext, sc);
entityMappings.add(em);
} else {
ModelEntityMapping em = new ModelEntityMapping(new GeneratedSpeciesSymbolTableEntry(sc), sc);
if (isSpatial) {
scs.initializeForSpatial();
}
entityMappings.add(em);
}
}
// for(SpeciesContext sc : sca) { // clean all the species patterns from the flattened species, we have no sp now
// sc.setSpeciesPattern(null);
// }
endTime = System.currentTimeMillis();
elapsedTime = endTime - startTime;
msg = "Adding " + outputSpec.getBNGSpecies().length + " species to model, " + elapsedTime + " ms";
System.out.println(msg);
// ---- Reactions -----------------------------------------------------------------------------------------------------
mathMappingCallback.setMessage("generating network: adding reactions...");
mathMappingCallback.setProgressFraction(progressFractionQuota / 4.0f * 3.0f);
startTime = System.currentTimeMillis();
System.out.println("\nReactions :");
Map<String, HashSet<String>> ruleKeyMap = new HashMap<String, HashSet<String>>();
Map<String, BNGReaction> directBNGReactionsMap = new HashMap<String, BNGReaction>();
Map<String, BNGReaction> reverseBNGReactionsMap = new HashMap<String, BNGReaction>();
for (int i = 0; i < outputSpec.getBNGReactions().length; i++) {
BNGReaction r = outputSpec.getBNGReactions()[i];
if (!r.isRuleReversed()) {
// direct
directBNGReactionsMap.put(r.getKey(), r);
} else {
reverseBNGReactionsMap.put(r.getKey(), r);
}
//
// for each rule name, store set of keySets (number of unique keysets are number of generated reactions from this ruleName).
//
HashSet<String> keySet = ruleKeyMap.get(r.getRuleName());
if (keySet == null) {
keySet = new HashSet<String>();
ruleKeyMap.put(r.getRuleName(), keySet);
}
keySet.add(r.getKey());
}
Map<String, ReactionStep> reactionStepMap = new HashMap<String, ReactionStep>();
for (int i = 0; i < outputSpec.getBNGReactions().length; i++) {
BNGReaction bngReaction = outputSpec.getBNGReactions()[i];
// System.out.println(i+1 + ":\t\t"+ r.writeReaction());
String baseName = bngReaction.getRuleName();
String reactionName = null;
HashSet<String> keySetsForThisRule = ruleKeyMap.get(bngReaction.getRuleName());
if (keySetsForThisRule.size() == 1 && model.getReactionStep(bngReaction.getRuleName()) == null && !reactionStepMap.containsKey(bngReaction.getRuleName())) {
// we can reuse the reaction rule labels
reactionName = bngReaction.getRuleName();
} else {
reactionName = bngReaction.getRuleName() + "_0";
while (true) {
if (model.getReactionStep(reactionName) == null && !reactionStepMap.containsKey(reactionName)) {
// we can reuse the reaction rule labels
break;
}
reactionName = TokenMangler.getNextEnumeratedToken(reactionName);
}
}
//
if (directBNGReactionsMap.containsValue(bngReaction)) {
BNGReaction forwardBNGReaction = bngReaction;
BNGReaction reverseBNGReaction = reverseBNGReactionsMap.get(bngReaction.getKey());
String name = forwardBNGReaction.getRuleName();
if (name.endsWith(ReactionRule.DirectHalf)) {
name = name.substring(0, name.indexOf(ReactionRule.DirectHalf));
}
if (name.endsWith(ReactionRule.InverseHalf)) {
name = name.substring(0, name.indexOf(ReactionRule.InverseHalf));
}
ReactionRule rr = model.getRbmModelContainer().getReactionRule(name);
Structure structure = rr.getStructure();
boolean bReversible = reverseBNGReaction != null;
SimpleReaction sr = new SimpleReaction(model, structure, reactionName, bReversible);
for (int j = 0; j < forwardBNGReaction.getReactants().length; j++) {
BNGSpecies s = forwardBNGReaction.getReactants()[j];
String scName = speciesMap.get(s.getNetworkFileIndex());
SpeciesContext sc = model.getSpeciesContext(scName);
Reactant reactant = sr.getReactant(scName);
if (reactant == null) {
int stoichiometry = 1;
sr.addReactant(sc, stoichiometry);
} else {
int stoichiometry = reactant.getStoichiometry();
stoichiometry += 1;
reactant.setStoichiometry(stoichiometry);
}
}
for (int j = 0; j < forwardBNGReaction.getProducts().length; j++) {
BNGSpecies s = forwardBNGReaction.getProducts()[j];
String scName = speciesMap.get(s.getNetworkFileIndex());
SpeciesContext sc = model.getSpeciesContext(scName);
Product product = sr.getProduct(scName);
if (product == null) {
int stoichiometry = 1;
sr.addProduct(sc, stoichiometry);
} else {
int stoichiometry = product.getStoichiometry();
stoichiometry += 1;
product.setStoichiometry(stoichiometry);
}
}
MassActionKinetics targetKinetics = new MassActionKinetics(sr);
sr.setKinetics(targetKinetics);
KineticsParameter kforward = targetKinetics.getForwardRateParameter();
KineticsParameter kreverse = targetKinetics.getReverseRateParameter();
String kforwardNewName = rr.getKineticLaw().getLocalParameter(RbmKineticLawParameterType.MassActionForwardRate).getName();
if (!kforward.getName().equals(kforwardNewName)) {
targetKinetics.renameParameter(kforward.getName(), kforwardNewName);
kforward = targetKinetics.getForwardRateParameter();
}
final String kreverseNewName = rr.getKineticLaw().getLocalParameter(RbmKineticLawParameterType.MassActionReverseRate).getName();
if (!kreverse.getName().equals(kreverseNewName)) {
targetKinetics.renameParameter(kreverse.getName(), kreverseNewName);
kreverse = targetKinetics.getReverseRateParameter();
}
applyKineticsExpressions(forwardBNGReaction, kforward, targetKinetics);
if (reverseBNGReaction != null) {
applyKineticsExpressions(reverseBNGReaction, kreverse, targetKinetics);
}
// String fieldParameterName = kforward.getName();
// fieldParameterName += "_" + r.getRuleName();
// kforward.setName(fieldParameterName);
reactionStepMap.put(reactionName, sr);
} else if (reverseBNGReactionsMap.containsValue(bngReaction) && !directBNGReactionsMap.containsKey(bngReaction.getKey())) {
// reverse only (must be irreversible)
BNGReaction reverseBNGReaction = reverseBNGReactionsMap.get(bngReaction.getKey());
ReactionRule rr = model.getRbmModelContainer().getReactionRule(reverseBNGReaction.extractRuleName());
Structure structure = rr.getStructure();
boolean bReversible = false;
SimpleReaction sr = new SimpleReaction(model, structure, reactionName, bReversible);
for (int j = 0; j < reverseBNGReaction.getReactants().length; j++) {
BNGSpecies s = reverseBNGReaction.getReactants()[j];
String scName = speciesMap.get(s.getNetworkFileIndex());
SpeciesContext sc = model.getSpeciesContext(scName);
Reactant reactant = sr.getReactant(scName);
if (reactant == null) {
int stoichiometry = 1;
sr.addReactant(sc, stoichiometry);
} else {
int stoichiometry = reactant.getStoichiometry();
stoichiometry += 1;
reactant.setStoichiometry(stoichiometry);
}
}
for (int j = 0; j < reverseBNGReaction.getProducts().length; j++) {
BNGSpecies s = reverseBNGReaction.getProducts()[j];
String scName = speciesMap.get(s.getNetworkFileIndex());
SpeciesContext sc = model.getSpeciesContext(scName);
Product product = sr.getProduct(scName);
if (product == null) {
int stoichiometry = 1;
sr.addProduct(sc, stoichiometry);
} else {
int stoichiometry = product.getStoichiometry();
stoichiometry += 1;
product.setStoichiometry(stoichiometry);
}
}
MassActionKinetics k = new MassActionKinetics(sr);
sr.setKinetics(k);
KineticsParameter kforward = k.getForwardRateParameter();
KineticsParameter kreverse = k.getReverseRateParameter();
String kforwardNewName = rr.getKineticLaw().getLocalParameter(RbmKineticLawParameterType.MassActionForwardRate).getName();
if (!kforward.getName().equals(kforwardNewName)) {
k.renameParameter(kforward.getName(), kforwardNewName);
kforward = k.getForwardRateParameter();
}
final String kreverseNewName = rr.getKineticLaw().getLocalParameter(RbmKineticLawParameterType.MassActionReverseRate).getName();
if (!kreverse.getName().equals(kreverseNewName)) {
k.renameParameter(kreverse.getName(), kreverseNewName);
kreverse = k.getReverseRateParameter();
}
applyKineticsExpressions(reverseBNGReaction, kforward, k);
// String fieldParameterName = kforward.getName();
// fieldParameterName += "_" + r.getRuleName();
// kforward.setName(fieldParameterName);
reactionStepMap.put(reactionName, sr);
}
}
for (ReactionStep rs : model.getReactionSteps()) {
reactionStepMap.put(rs.getName(), rs);
}
ReactionStep[] reactionSteps = new ReactionStep[reactionStepMap.size()];
reactionStepMap.values().toArray(reactionSteps);
model.setReactionSteps(reactionSteps);
if (mathMappingCallback.isInterrupted()) {
msg = "Canceled by user.";
tcm = new TaskCallbackMessage(TaskCallbackStatus.Error, msg);
simContext.appendToConsole(tcm);
throw new UserCancelException(msg);
}
endTime = System.currentTimeMillis();
elapsedTime = endTime - startTime;
msg = "Adding " + outputSpec.getBNGReactions().length + " reactions to model, " + elapsedTime + " ms";
System.out.println(msg);
// clean all the reaction rules
model.getRbmModelContainer().getReactionRuleList().clear();
// ---- Observables -------------------------------------------------------------------------------------------------
mathMappingCallback.setMessage("generating network: adding observables...");
mathMappingCallback.setProgressFraction(progressFractionQuota / 8.0f * 7.0f);
startTime = System.currentTimeMillis();
System.out.println("\nObservables :");
RbmModelContainer rbmmc = model.getRbmModelContainer();
for (int i = 0; i < outputSpec.getObservableGroups().length; i++) {
ObservableGroup o = outputSpec.getObservableGroups()[i];
if (rbmmc.getParameter(o.getObservableGroupName()) != null) {
System.out.println(" ...already exists.");
// if it's already there we don't try to add it again; this should be true for all of them!
continue;
}
ArrayList<Expression> terms = new ArrayList<Expression>();
for (int j = 0; j < o.getListofSpecies().length; j++) {
Expression term = Expression.mult(new Expression(o.getSpeciesMultiplicity()[j]), new Expression(speciesMap.get(o.getListofSpecies()[j].getNetworkFileIndex())));
terms.add(term);
}
Expression exp = Expression.add(terms.toArray(new Expression[terms.size()])).flatten();
exp.bindExpression(rbmmc.getSymbolTable());
RbmObservable originalObservable = rbmmc.getObservable(o.getObservableGroupName());
VCUnitDefinition observableUnitDefinition = originalObservable.getUnitDefinition();
rbmmc.removeObservable(originalObservable);
Parameter newParameter = rbmmc.addParameter(o.getObservableGroupName(), exp, observableUnitDefinition);
RbmObservable origObservable = simContext.getModel().getRbmModelContainer().getObservable(o.getObservableGroupName());
ModelEntityMapping em = new ModelEntityMapping(origObservable, newParameter);
entityMappings.add(em);
}
if (mathMappingCallback.isInterrupted()) {
msg = "Canceled by user.";
tcm = new TaskCallbackMessage(TaskCallbackStatus.Error, msg);
simContext.appendToConsole(tcm);
throw new UserCancelException(msg);
}
endTime = System.currentTimeMillis();
elapsedTime = endTime - startTime;
msg = "Adding " + outputSpec.getObservableGroups().length + " observables to model, " + elapsedTime + " ms";
System.out.println(msg);
} catch (PropertyVetoException ex) {
ex.printStackTrace(System.out);
throw new RuntimeException(ex.getMessage());
} catch (ExpressionBindingException ex) {
ex.printStackTrace(System.out);
throw new RuntimeException(ex.getMessage());
} catch (ModelException ex) {
ex.printStackTrace(System.out);
throw new RuntimeException(ex.getMessage());
} catch (ExpressionException ex) {
ex.printStackTrace(System.out);
throw new RuntimeException(ex.getMessage());
} catch (ClassNotFoundException ex) {
throw new RuntimeException(ex.getMessage());
} catch (IOException ex) {
throw new RuntimeException(ex.getMessage());
}
System.out.println("Done transforming");
msg = "Generating math...";
System.out.println(msg);
mathMappingCallback.setMessage(msg);
mathMappingCallback.setProgressFraction(progressFractionQuota);
}
Also used :
HashMap(java.util.HashMap)
LinkedHashMap(java.util.LinkedHashMap)
UserCancelException(org.vcell.util.UserCancelException)
ArrayList(java.util.ArrayList)
Product(cbit.vcell.model.Product)
SpeciesContext(cbit.vcell.model.SpeciesContext)
FakeSeedSpeciesInitialConditionsParameter(org.vcell.model.rbm.FakeSeedSpeciesInitialConditionsParameter)
Reactant(cbit.vcell.model.Reactant)
BNGOutputSpec(cbit.vcell.bionetgen.BNGOutputSpec)
ExpressionException(cbit.vcell.parser.ExpressionException)
LinkedHashMap(java.util.LinkedHashMap)
FakeReactionRuleRateParameter(org.vcell.model.rbm.FakeReactionRuleRateParameter)
KineticsParameter(cbit.vcell.model.Kinetics.KineticsParameter)
RbmModelContainer(cbit.vcell.model.Model.RbmModelContainer)
Species(cbit.vcell.model.Species)
BNGSpecies(cbit.vcell.bionetgen.BNGSpecies)
HashSet(java.util.HashSet)
BNGParameter(cbit.vcell.bionetgen.BNGParameter)
ModelException(cbit.vcell.model.ModelException)
ObservableGroup(cbit.vcell.bionetgen.ObservableGroup)
RbmObservable(cbit.vcell.model.RbmObservable)
PropertyVetoException(java.beans.PropertyVetoException)
BNGReaction(cbit.vcell.bionetgen.BNGReaction)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
ReactionStep(cbit.vcell.model.ReactionStep)
Map(java.util.Map)
HashMap(java.util.HashMap)
LinkedHashMap(java.util.LinkedHashMap)
SpeciesPattern(org.vcell.model.rbm.SpeciesPattern)
Structure(cbit.vcell.model.Structure)
SimpleReaction(cbit.vcell.model.SimpleReaction)
ReactionRule(cbit.vcell.model.ReactionRule)
IOException(java.io.IOException)
ExpressionBindingException(cbit.vcell.parser.ExpressionBindingException)
Expression(cbit.vcell.parser.Expression)
Model(cbit.vcell.model.Model)
FakeSeedSpeciesInitialConditionsParameter(org.vcell.model.rbm.FakeSeedSpeciesInitialConditionsParameter)
Parameter(cbit.vcell.model.Parameter)
KineticsParameter(cbit.vcell.model.Kinetics.KineticsParameter)
LocalParameter(cbit.vcell.mapping.ParameterContext.LocalParameter)
BNGParameter(cbit.vcell.bionetgen.BNGParameter)
FakeReactionRuleRateParameter(org.vcell.model.rbm.FakeReactionRuleRateParameter)
MassActionKinetics(cbit.vcell.model.MassActionKinetics)
ParseException(org.vcell.model.bngl.ParseException)
BNGSpecies(cbit.vcell.bionetgen.BNGSpecies)
Example 12 with SimpleReaction
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class ITextWriter method writeReactions.
// each reaction has its own table, ordered by the structures.
protected void writeReactions(Chapter physioChapter, Model model) throws DocumentException {
if (model == null) {
return;
}
Paragraph reactionParagraph = new Paragraph();
reactionParagraph.add(new Chunk("Structures and Reactions Diagram").setLocalDestination(model.getName()));
Section reactionDiagramSection = physioChapter.addSection(reactionParagraph, physioChapter.numberDepth() + 1);
try {
addImage(reactionDiagramSection, encodeJPEG(generateDocReactionsImage(model, null)));
} catch (Exception e) {
e.printStackTrace();
throw new DocumentException(e.getClass().getName() + ": " + e.getMessage());
}
for (int i = 0; i < model.getNumStructures(); i++) {
ReactionStep[] reactionSteps = model.getReactionSteps();
ReactionStep rs = null;
Table modifierTable = null;
Table reactionTable = null;
boolean firstTime = true;
Section reactStructSection = null;
for (int j = 0; j < reactionSteps.length; j++) {
if (reactionSteps[j].getStructure() == model.getStructure(i)) {
// can also use structureName1.equals(structureName2)
if (firstTime) {
Paragraph linkParagraph = new Paragraph();
linkParagraph.add(new Chunk("Reaction(s) in " + model.getStructure(i).getName()).setLocalDestination(model.getStructure(i).getName()));
reactStructSection = physioChapter.addSection(linkParagraph, physioChapter.numberDepth() + 1);
firstTime = false;
}
rs = reactionSteps[j];
String type;
if (rs instanceof SimpleReaction) {
type = "Reaction";
} else {
type = "Flux";
}
// write Reaction equation as a table
// Get the image arrow cell depending on type of reactionStep : MassAction => double arrow, otherwise, forward arrow
boolean bReversible = false;
if (rs.getKinetics() instanceof MassActionKinetics) {
bReversible = true;
}
Cell arrowImageCell = getReactionArrowImageCell(bReversible);
// Get reactants and products strings
ReactionCanvas rc = new ReactionCanvas();
rc.setReactionStep(rs);
ReactionCanvasDisplaySpec rcdSpec = rc.getReactionCanvasDisplaySpec();
String reactants = rcdSpec.getLeftText();
String products = rcdSpec.getRightText();
// Create table and add cells for reactants, arrow(s) images, products
int[] widths = { 8, 1, 8 };
reactionTable = getTable(3, 100, 0, 2, 2);
// Add reactants as cell
Cell tableCell = createCell(reactants, getBold());
tableCell.setHorizontalAlignment(Cell.ALIGN_RIGHT);
tableCell.setBorderColor(Color.white);
reactionTable.addCell(tableCell);
// add arrow(s) image as cell
if (arrowImageCell != null) {
arrowImageCell.setHorizontalAlignment(Cell.ALIGN_CENTER);
arrowImageCell.setBorderColor(Color.white);
reactionTable.addCell(arrowImageCell);
}
// add products as cell
tableCell = createCell(products, getBold());
tableCell.setBorderColor(Color.white);
reactionTable.addCell(tableCell);
// reactionTable.setBorderColor(Color.white);
reactionTable.setWidths(widths);
// Identify modifiers,
ReactionParticipant[] rpArr = rs.getReactionParticipants();
Vector<ReactionParticipant> modifiersVector = new Vector<ReactionParticipant>();
for (int k = 0; k < rpArr.length; k += 1) {
if (rpArr[k] instanceof Catalyst) {
modifiersVector.add(rpArr[k]);
}
}
// Write the modifiers in a separate table, if present
if (modifiersVector.size() > 0) {
modifierTable = getTable(1, 50, 0, 1, 1);
modifierTable.addCell(createCell("Modifiers List", getBold(DEF_HEADER_FONT_SIZE), 1, 1, Element.ALIGN_CENTER, true));
StringBuffer modifierNames = new StringBuffer();
for (int k = 0; k < modifiersVector.size(); k++) {
modifierNames.append(((Catalyst) modifiersVector.elementAt(k)).getName() + "\n");
}
modifierTable.addCell(createCell(modifierNames.toString().trim(), getFont()));
modifiersVector.removeAllElements();
}
Section reactionSection = reactStructSection.addSection(type + " " + rs.getName(), reactStructSection.numberDepth() + 1);
// Annotation
VCMetaData vcMetaData = rs.getModel().getVcMetaData();
if (vcMetaData.getFreeTextAnnotation(rs) != null) {
Table annotTable = getTable(1, 100, 1, 3, 3);
annotTable.addCell(createCell("Reaction Annotation", getBold(DEF_HEADER_FONT_SIZE), 1, 1, Element.ALIGN_CENTER, true));
annotTable.addCell(createCell(vcMetaData.getFreeTextAnnotation(rs), getFont()));
reactionSection.add(annotTable);
// reactionSection.add(new Paragraph("\""+rs.getAnnotation()+"\""));
}
// reaction table
if (reactionTable != null) {
reactionSection.add(reactionTable);
// re-set reactionTable
reactionTable = null;
}
if (modifierTable != null) {
reactionSection.add(modifierTable);
modifierTable = null;
}
// Write kinetics parameters, etc. in a table
writeKineticsParams(reactionSection, rs);
}
}
}
}
Also used :
Table(com.lowagie.text.Table)
SimpleReaction(cbit.vcell.model.SimpleReaction)
ReactionCanvasDisplaySpec(cbit.vcell.model.ReactionCanvasDisplaySpec)
ReactionCanvas(cbit.vcell.model.ReactionCanvas)
Chunk(com.lowagie.text.Chunk)
Section(com.lowagie.text.Section)
DocumentException(com.lowagie.text.DocumentException)
ExpressionException(cbit.vcell.parser.ExpressionException)
Paragraph(com.lowagie.text.Paragraph)
VCMetaData(cbit.vcell.biomodel.meta.VCMetaData)
DocumentException(com.lowagie.text.DocumentException)
ReactionStep(cbit.vcell.model.ReactionStep)
MassActionKinetics(cbit.vcell.model.MassActionKinetics)
Cell(com.lowagie.text.Cell)
ReactionParticipant(cbit.vcell.model.ReactionParticipant)
Vector(java.util.Vector)
Catalyst(cbit.vcell.model.Catalyst)
Example 13 with SimpleReaction
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class ReactionPropertiesPanel method getKineticsTypeComboBox.
private javax.swing.JComboBox getKineticsTypeComboBox() {
if (kineticsTypeComboBox == null) {
try {
kineticsTypeComboBox = new javax.swing.JComboBox();
kineticsTypeComboBox.setName("JComboBox1");
kineticsTypeComboBox.setRenderer(new DefaultListCellRenderer() {
private static final String MU = "\u03BC";
private static final String MICROMOLAR = MU + "M";
private static final String SQUARED = "\u00B2";
private static final String SQUAREMICRON = MU + "m" + SQUARED;
private static final String MICRON = MU + "m";
public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
java.awt.Component component = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
if (value instanceof KineticsDescription) {
KineticsDescription kineticsDescription = (KineticsDescription) value;
setText(kineticsDescription.getDescription());
if (reactionStep != null) {
if (reactionStep instanceof SimpleReaction) {
if (reactionStep.getStructure() instanceof Feature) {
if (kineticsDescription.equals(KineticsDescription.General)) {
setText("General [" + MICROMOLAR + "/s]");
} else if (kineticsDescription.equals(KineticsDescription.MassAction)) {
setText("Mass Action [" + MICROMOLAR + "/s] (recommended for stochastic application)");
} else if (kineticsDescription.equals(KineticsDescription.GeneralLumped)) {
setText("General [molecules/s]");
} else if (kineticsDescription.equals(KineticsDescription.HMM_irreversible)) {
setText("Henri-Michaelis-Menten (Irreversible) [" + MICROMOLAR + "/s]");
} else if (kineticsDescription.equals(KineticsDescription.HMM_reversible)) {
setText("Henri-Michaelis-Menten (Reversible) [" + MICROMOLAR + "/s]");
} else {
setText(kineticsDescription.getDescription());
}
} else if (reactionStep.getStructure() instanceof Membrane) {
if (kineticsDescription.equals(KineticsDescription.General)) {
setText("General [molecules/(" + SQUAREMICRON + " s)]");
} else if (kineticsDescription.equals(KineticsDescription.MassAction)) {
setText("Mass Action [molecules/(" + SQUAREMICRON + " s)]");
} else if (kineticsDescription.equals(KineticsDescription.GeneralLumped)) {
setText("General [molecules/s)]");
} else if (kineticsDescription.equals(KineticsDescription.HMM_irreversible)) {
setText("Henri-Michaelis-Menten (Irreversible) [molecules/(" + SQUAREMICRON + " s)]");
} else if (kineticsDescription.equals(KineticsDescription.HMM_reversible)) {
setText("Henri-Michaelis-Menten (Reversible) [molecules/(" + SQUAREMICRON + " s)]");
} else if (kineticsDescription.equals(KineticsDescription.Macroscopic_irreversible)) {
setText("Macroscopic (Irreversible) [molecules/(" + SQUAREMICRON + " s)]");
} else if (kineticsDescription.equals(KineticsDescription.Microscopic_irreversible)) {
setText("Microscopic (Irreversible) [molecules/(" + SQUAREMICRON + " s)]");
}
}
} else if (reactionStep instanceof FluxReaction) {
if (kineticsDescription.equals(KineticsDescription.General)) {
setText("General Flux Density (" + MICROMOLAR + "-" + MICRON + "/s)");
} else if (kineticsDescription.equals(KineticsDescription.GeneralLumped)) {
setText("General Flux (molecules/s)");
} else if (kineticsDescription.equals(KineticsDescription.GeneralCurrent)) {
setText("General Current Density (pA/" + SQUAREMICRON + ")");
} else if (kineticsDescription.equals(KineticsDescription.GeneralCurrentLumped)) {
setText("General Current (pA)");
} else if (kineticsDescription.equals(KineticsDescription.GHK)) {
setText("Goldman-Hodgkin-Katz Current Density (pA/" + SQUAREMICRON + ") - permeability in " + MICRON + "/s");
} else if (kineticsDescription.equals(KineticsDescription.Nernst)) {
setText("Nernst Current Density (pA/" + SQUAREMICRON + ") - conductance in nS/" + SQUAREMICRON);
} else if (kineticsDescription.equals(KineticsDescription.GeneralPermeability)) {
setText("General Permeability (" + MICROMOLAR + "-" + MICRON + "/s) - permeability in " + MICRON + "/s");
}
}
}
}
return component;
}
});
// user code begin {1}
// user code end
} catch (java.lang.Throwable ivjExc) {
// user code begin {2}
// user code end
handleException(ivjExc);
}
}
return kineticsTypeComboBox;
}
Also used :
SimpleReaction(cbit.vcell.model.SimpleReaction)
KineticsDescription(cbit.vcell.model.KineticsDescription)
FluxReaction(cbit.vcell.model.FluxReaction)
Feature(cbit.vcell.model.Feature)
DefaultListCellRenderer(javax.swing.DefaultListCellRenderer)
Membrane(cbit.vcell.model.Membrane)
BioPaxObject(org.vcell.pathway.BioPaxObject)
RelationshipObject(org.vcell.relationship.RelationshipObject)
Component(java.awt.Component)
JList(javax.swing.JList)
Example 14 with SimpleReaction
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class ReactionPropertiesPanel method initKineticChoices.
private void initKineticChoices() {
KineticsDescription[] kineticTypes = reactionStep == null || reactionStep instanceof SimpleReaction ? Simple_Reaction_Kinetic_Types : Flux_Reaction_KineticTypes;
javax.swing.DefaultComboBoxModel model = new DefaultComboBoxModel();
for (int i = 0; i < kineticTypes.length; i++) {
if (!(kineticTypes[i].equals(KineticsDescription.Macroscopic_irreversible) || kineticTypes[i].equals(KineticsDescription.Microscopic_irreversible))) {
model.addElement(kineticTypes[i]);
} else // macroscopic/microscopic irreversible
{
// reactions on membrane in a 3D geometry
if (reactionStep != null && reactionStep.getStructure() != null && reactionStep.getStructure() instanceof Membrane) {
// check if reactants are all on membrane and calculate sum of reactants' stoichiometry
ReactionParticipant[] rps = reactionStep.getReactionParticipants();
int order = 0;
boolean bAllMembraneReactants = true;
for (ReactionParticipant rp : rps) {
if (rp instanceof Reactant) {
if (!(rp.getStructure() instanceof Membrane)) {
bAllMembraneReactants = false;
break;
}
order += rp.getStoichiometry();
}
}
// add only if 2nd order membrane reaction
if (order == 2 && bAllMembraneReactants && !reactionStep.hasCatalyst()) {
model.addElement(kineticTypes[i]);
}
}
}
}
getKineticsTypeComboBox().setModel(model);
return;
}
Also used :
SimpleReaction(cbit.vcell.model.SimpleReaction)
KineticsDescription(cbit.vcell.model.KineticsDescription)
Membrane(cbit.vcell.model.Membrane)
DefaultComboBoxModel(javax.swing.DefaultComboBoxModel)
DefaultComboBoxModel(javax.swing.DefaultComboBoxModel)
ReactionParticipant(cbit.vcell.model.ReactionParticipant)
Reactant(cbit.vcell.model.Reactant)
Example 15 with SimpleReaction
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class Generate2DExpModelOpAbstract method generateModel.
public final GeneratedModelResults generateModel(double deltaX, double bleachRadius, double cellRadius, double bleachDuration, double bleachRate, double postbleachDelay, double postbleachDuration, double psfSigma, double outputTimeStep, double primaryDiffusionRate, double primaryFraction, double bleachMonitorRate, double secondaryDiffusionRate, double secondaryFraction, String extracellularName, String cytosolName, Context context) throws PropertyVetoException, ExpressionException, GeometryException, ImageException, ModelException, MappingException, MathException, MatrixException {
double domainSize = 2.2 * cellRadius;
Extent extent = new Extent(domainSize, domainSize, 1.0);
Origin origin = new Origin(-extent.getX() / 2.0, -extent.getY() / 2.0, -extent.getZ() / 2.0);
String EXTRACELLULAR_NAME = extracellularName;
String CYTOSOL_NAME = cytosolName;
AnalyticSubVolume cytosolSubVolume = new AnalyticSubVolume(CYTOSOL_NAME, new Expression("pow(x,2)+pow(y,2)<pow(" + cellRadius + ",2)"));
AnalyticSubVolume extracellularSubVolume = new AnalyticSubVolume(EXTRACELLULAR_NAME, new Expression(1.0));
Geometry geometry = new Geometry("geometry", 2);
geometry.getGeometrySpec().setExtent(extent);
geometry.getGeometrySpec().setOrigin(origin);
geometry.getGeometrySpec().addSubVolume(extracellularSubVolume);
geometry.getGeometrySpec().addSubVolume(cytosolSubVolume, true);
geometry.getGeometrySurfaceDescription().updateAll();
BioModel bioModel = new BioModel(null);
bioModel.setName("unnamed");
Model model = new Model("model");
bioModel.setModel(model);
model.addFeature(EXTRACELLULAR_NAME);
Feature extracellular = (Feature) model.getStructure(EXTRACELLULAR_NAME);
model.addFeature(CYTOSOL_NAME);
Feature cytosol = (Feature) model.getStructure(CYTOSOL_NAME);
SpeciesContext immobileSC = model.createSpeciesContext(cytosol);
SpeciesContext primarySC = model.createSpeciesContext(cytosol);
SpeciesContext secondarySC = model.createSpeciesContext(cytosol);
//
// common bleaching rate for all species
//
double bleachStart = 10 * outputTimeStep - bleachDuration - postbleachDelay;
double bleachEnd = bleachStart + bleachDuration;
Expression bleachRateExp = createBleachExpression(bleachRadius, bleachRate, bleachMonitorRate, bleachStart, bleachEnd);
{
SimpleReaction immobileBWM = model.createSimpleReaction(cytosol);
GeneralKinetics immobileBWMKinetics = new GeneralKinetics(immobileBWM);
immobileBWM.setKinetics(immobileBWMKinetics);
immobileBWM.addReactant(immobileSC, 1);
immobileBWMKinetics.getReactionRateParameter().setExpression(Expression.mult(bleachRateExp, new Expression(immobileSC.getName())));
}
{
SimpleReaction primaryBWM = model.createSimpleReaction(cytosol);
GeneralKinetics primaryBWMKinetics = new GeneralKinetics(primaryBWM);
primaryBWM.setKinetics(primaryBWMKinetics);
primaryBWM.addReactant(primarySC, 1);
primaryBWMKinetics.getReactionRateParameter().setExpression(Expression.mult(bleachRateExp, new Expression(primarySC.getName())));
}
{
SimpleReaction secondaryBWM = model.createSimpleReaction(cytosol);
GeneralKinetics secondaryBWMKinetics = new GeneralKinetics(secondaryBWM);
secondaryBWM.setKinetics(secondaryBWMKinetics);
secondaryBWM.addReactant(secondarySC, 1);
secondaryBWMKinetics.getReactionRateParameter().setExpression(Expression.mult(bleachRateExp, new Expression(secondarySC.getName())));
}
// create simulation context
SimulationContext simContext = bioModel.addNewSimulationContext("simContext", SimulationContext.Application.NETWORK_DETERMINISTIC);
simContext.setGeometry(geometry);
FeatureMapping cytosolFeatureMapping = (FeatureMapping) simContext.getGeometryContext().getStructureMapping(cytosol);
FeatureMapping extracellularFeatureMapping = (FeatureMapping) simContext.getGeometryContext().getStructureMapping(extracellular);
SubVolume cytSubVolume = geometry.getGeometrySpec().getSubVolume(CYTOSOL_NAME);
SubVolume exSubVolume = geometry.getGeometrySpec().getSubVolume(EXTRACELLULAR_NAME);
// unused? SurfaceClass pmSurfaceClass = geometry.getGeometrySurfaceDescription().getSurfaceClass(exSubVolume, cytSubVolume);
cytosolFeatureMapping.setGeometryClass(cytSubVolume);
extracellularFeatureMapping.setGeometryClass(exSubVolume);
cytosolFeatureMapping.getUnitSizeParameter().setExpression(new Expression(1.0));
extracellularFeatureMapping.getUnitSizeParameter().setExpression(new Expression(1.0));
double fixedFraction = 1.0 - primaryFraction - secondaryFraction;
SpeciesContextSpec immobileSCS = simContext.getReactionContext().getSpeciesContextSpec(immobileSC);
immobileSCS.getInitialConditionParameter().setExpression(new Expression(fixedFraction));
immobileSCS.getDiffusionParameter().setExpression(new Expression(0.0));
SpeciesContextSpec primarySCS = simContext.getReactionContext().getSpeciesContextSpec(primarySC);
primarySCS.getInitialConditionParameter().setExpression(new Expression(primaryFraction));
primarySCS.getDiffusionParameter().setExpression(new Expression(primaryDiffusionRate));
SpeciesContextSpec secondarySCS = simContext.getReactionContext().getSpeciesContextSpec(secondarySC);
secondarySCS.getInitialConditionParameter().setExpression(new Expression(secondaryFraction));
secondarySCS.getDiffusionParameter().setExpression(new Expression(secondaryDiffusionRate));
simContext.getMicroscopeMeasurement().addFluorescentSpecies(immobileSC);
simContext.getMicroscopeMeasurement().addFluorescentSpecies(primarySC);
simContext.getMicroscopeMeasurement().addFluorescentSpecies(secondarySC);
simContext.getMicroscopeMeasurement().setConvolutionKernel(new GaussianConvolutionKernel(new Expression(psfSigma), new Expression(psfSigma)));
MathMapping mathMapping = simContext.createNewMathMapping();
MathDescription mathDesc = mathMapping.getMathDescription();
simContext.setMathDescription(mathDesc);
User owner = context.getDefaultOwner();
int meshSize = (int) (domainSize / deltaX);
if (meshSize % 2 == 0) {
// want an odd-sized mesh in x and y ... so centered at the origin.
meshSize = meshSize + 1;
}
TimeBounds timeBounds = new TimeBounds(0.0, postbleachDuration);
//
// simulation to use for data generation (output time steps as recorded by the microscope)
//
double bleachBlackoutBegin = bleachStart - postbleachDelay;
double bleachBlackoutEnd = bleachEnd + postbleachDelay;
// ArrayList<Double> times = new ArrayList<Double>();
// double time = 0;
// while (time<=timeBounds.getEndingTime()){
// if (time<=bleachBlackoutBegin || time>bleachBlackoutEnd){
// // postbleachDelay is the time it takes to switch the filters.
// times.add(time);
// }
// time += outputTimeStep.getData();
// }
// double[] timeArray = new double[times.size()];
// for (int i=0;i<timeArray.length;i++){
// timeArray[i] = times.get(i);
// }
// OutputTimeSpec fakeDataSimOutputTimeSpec = new ExplicitOutputTimeSpec(timeArray);
OutputTimeSpec fakeDataSimOutputTimeSpec = new UniformOutputTimeSpec(outputTimeStep);
KeyValue fakeDataSimKey = context.createNewKeyValue();
SimulationVersion fakeDataSimVersion = new SimulationVersion(fakeDataSimKey, "fakeDataSim", owner, new GroupAccessNone(), new KeyValue("0"), new BigDecimal(0), new Date(), VersionFlag.Current, "", null);
Simulation fakeDataSim = new Simulation(fakeDataSimVersion, mathDesc);
simContext.addSimulation(fakeDataSim);
fakeDataSim.getSolverTaskDescription().setTimeBounds(timeBounds);
fakeDataSim.getMeshSpecification().setSamplingSize(new ISize(meshSize, meshSize, 1));
fakeDataSim.getSolverTaskDescription().setSolverDescription(SolverDescription.SundialsPDE);
fakeDataSim.getSolverTaskDescription().setOutputTimeSpec(fakeDataSimOutputTimeSpec);
//
// simulation to use for viewing the protocol (output time steps to understand the physics)
//
KeyValue fullExperimentSimKey = context.createNewKeyValue();
SimulationVersion fullExperimentSimVersion = new SimulationVersion(fullExperimentSimKey, "fullExperiment", owner, new GroupAccessNone(), new KeyValue("0"), new BigDecimal(0), new Date(), VersionFlag.Current, "", null);
Simulation fullExperimentSim = new Simulation(fullExperimentSimVersion, mathDesc);
simContext.addSimulation(fullExperimentSim);
OutputTimeSpec fullExperimentOutputTimeSpec = new UniformOutputTimeSpec(outputTimeStep / 10.0);
fullExperimentSim.getSolverTaskDescription().setTimeBounds(timeBounds);
fullExperimentSim.getMeshSpecification().setSamplingSize(new ISize(meshSize, meshSize, 1));
fullExperimentSim.getSolverTaskDescription().setSolverDescription(SolverDescription.SundialsPDE);
fullExperimentSim.getSolverTaskDescription().setOutputTimeSpec(fullExperimentOutputTimeSpec);
GeneratedModelResults results = new GeneratedModelResults();
results.bioModel_2D = bioModel;
results.simulation_2D = fakeDataSim;
results.bleachBlackoutBeginTime = bleachBlackoutBegin;
results.bleachBlackoutEndTime = bleachBlackoutEnd;
return results;
}
Also used :
Origin(org.vcell.util.Origin)
User(org.vcell.util.document.User)
KeyValue(org.vcell.util.document.KeyValue)
Extent(org.vcell.util.Extent)
MathDescription(cbit.vcell.math.MathDescription)
ISize(org.vcell.util.ISize)
SpeciesContext(cbit.vcell.model.SpeciesContext)
GeneralKinetics(cbit.vcell.model.GeneralKinetics)
SpeciesContextSpec(cbit.vcell.mapping.SpeciesContextSpec)
Feature(cbit.vcell.model.Feature)
TimeBounds(cbit.vcell.solver.TimeBounds)
GroupAccessNone(org.vcell.util.document.GroupAccessNone)
UniformOutputTimeSpec(cbit.vcell.solver.UniformOutputTimeSpec)
OutputTimeSpec(cbit.vcell.solver.OutputTimeSpec)
SimulationVersion(org.vcell.util.document.SimulationVersion)
FeatureMapping(cbit.vcell.mapping.FeatureMapping)
SubVolume(cbit.vcell.geometry.SubVolume)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
SimpleReaction(cbit.vcell.model.SimpleReaction)
UniformOutputTimeSpec(cbit.vcell.solver.UniformOutputTimeSpec)
SimulationContext(cbit.vcell.mapping.SimulationContext)
GaussianConvolutionKernel(cbit.vcell.mapping.MicroscopeMeasurement.GaussianConvolutionKernel)
BigDecimal(java.math.BigDecimal)
Date(java.util.Date)
Geometry(cbit.vcell.geometry.Geometry)
Simulation(cbit.vcell.solver.Simulation)
Expression(cbit.vcell.parser.Expression)
BioModel(cbit.vcell.biomodel.BioModel)
BioModel(cbit.vcell.biomodel.BioModel)
Model(cbit.vcell.model.Model)
MathMapping(cbit.vcell.mapping.MathMapping)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
Aggregations
SimpleReaction (cbit.vcell.model.SimpleReaction)49
FluxReaction (cbit.vcell.model.FluxReaction)26
SpeciesContext (cbit.vcell.model.SpeciesContext)22
ReactionParticipant (cbit.vcell.model.ReactionParticipant)20
ReactionStep (cbit.vcell.model.ReactionStep)19
Structure (cbit.vcell.model.Structure)19
Expression (cbit.vcell.parser.Expression)19
Membrane (cbit.vcell.model.Membrane)16
Feature (cbit.vcell.model.Feature)15
Reactant (cbit.vcell.model.Reactant)15
ArrayList (java.util.ArrayList)14
KineticsParameter (cbit.vcell.model.Kinetics.KineticsParameter)13
Product (cbit.vcell.model.Product)12
PropertyVetoException (java.beans.PropertyVetoException)12
Model (cbit.vcell.model.Model)10
Kinetics (cbit.vcell.model.Kinetics)9
MassActionKinetics (cbit.vcell.model.MassActionKinetics)9
Point (java.awt.Point)9
Shape (cbit.gui.graph.Shape)8
BioModel (cbit.vcell.biomodel.BioModel)7
