use of cbit.vcell.math.ParticleMolecularType in project vcell by virtualcell.
the class NFsimXMLWriter method getListOfMoleculeTypes.
private static Element getListOfMoleculeTypes(MathDescription mathDesc) {
Element listOfMoleculeTypesElement = new Element("ListOfMoleculeTypes");
for (ParticleMolecularType molecularType : mathDesc.getParticleMolecularTypes()) {
Element molecularTypeElement = new Element("MoleculeType");
molecularTypeElement.setAttribute("id", molecularType.getName());
// TODO molecularTypeElement.setAttribute("population","1");
Element listOfComponentTypesElement = getListOfComponentTypes(molecularType);
if (listOfComponentTypesElement != null) {
molecularTypeElement.addContent(listOfComponentTypesElement);
}
for (String anchor : molecularType.getAnchorList()) {
Element a = new Element(XMLTags.ParticleMolecularTypeAnchorTag);
a.setAttribute(XMLTags.NameAttrTag, anchor);
molecularTypeElement.addContent(a);
}
// TODO: uncomment the next 2 lines to set anchor existence attribute
boolean hasAnchors = !molecularType.getAnchorList().isEmpty();
molecularTypeElement.setAttribute("hasAnchors", hasAnchors + "");
listOfMoleculeTypesElement.addContent(molecularTypeElement);
}
return listOfMoleculeTypesElement;
}
use of cbit.vcell.math.ParticleMolecularType in project vcell by virtualcell.
the class NFsimXMLWriter method writeNFsimXML.
public static Element writeNFsimXML(SimulationTask origSimTask, long randomSeed, NFsimSimulationOptions nfsimSimulationOptions, boolean bUseLocationMarks) throws SolverException {
try {
System.out.println("VCML ORIGINAL .... START\n" + origSimTask.getSimulation().getMathDescription().getVCML_database() + "\nVCML ORIGINAL .... END\n====================\n");
} catch (MathException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
SimulationTask clonedSimTask = null;
try {
clonedSimTask = (SimulationTask) BeanUtils.cloneSerializable(origSimTask);
} catch (Exception eee) {
throw new SolverException("failed to clone mathDescription while preparing NFSim input: " + eee.getMessage(), eee);
}
MathDescription clonedMathDesc = clonedSimTask.getSimulation().getMathDescription();
if (bUseLocationMarks) {
try {
//
// get list of Compartment Names (stored in locations).
//
ArrayList<String> locations = new ArrayList<String>();
Enumeration<Variable> varEnum = clonedMathDesc.getVariables();
ArrayList<VolumeParticleSpeciesPattern> volumeParticleSpeciesPatterns = new ArrayList<VolumeParticleSpeciesPattern>();
while (varEnum.hasMoreElements()) {
Variable var = varEnum.nextElement();
if (var instanceof VolumeParticleSpeciesPattern) {
VolumeParticleSpeciesPattern speciesPattern = (VolumeParticleSpeciesPattern) var;
if (!locations.contains(speciesPattern.getLocationName())) {
locations.add(speciesPattern.getLocationName());
}
volumeParticleSpeciesPatterns.add(speciesPattern);
}
}
//
for (ParticleMolecularType particleMolecularType : clonedMathDesc.getParticleMolecularTypes()) {
String pmcLocationName = RbmUtils.SiteStruct;
String pmcLocationId = particleMolecularType.getName() + "_" + RbmUtils.SiteStruct;
ParticleMolecularComponent locationComponent = new ParticleMolecularComponent(pmcLocationId, pmcLocationName);
for (String location : locations) {
locationComponent.addComponentStateDefinition(new ParticleComponentStateDefinition(location));
}
particleMolecularType.insertMolecularComponent(0, locationComponent);
String pmcMarkName = RbmUtils.SiteProduct;
String pmcMarkId = particleMolecularType.getName() + "_" + RbmUtils.SiteProduct;
ParticleMolecularComponent markComponent = new ParticleMolecularComponent(pmcMarkId, pmcMarkName);
markComponent.addComponentStateDefinition(new ParticleComponentStateDefinition("0"));
markComponent.addComponentStateDefinition(new ParticleComponentStateDefinition("1"));
particleMolecularType.insertMolecularComponent(1, markComponent);
}
//
for (VolumeParticleSpeciesPattern speciesPattern : volumeParticleSpeciesPatterns) {
for (ParticleMolecularTypePattern molTypePattern : speciesPattern.getParticleMolecularTypePatterns()) {
//
// add location component to pattern ... state=<location>
//
{
final ParticleMolecularComponent locationComponentDefinition = molTypePattern.getMolecularType().getComponentList().get(0);
ParticleMolecularComponentPattern locationPattern = new ParticleMolecularComponentPattern(locationComponentDefinition);
ParticleComponentStateDefinition locationStateDefinition = null;
for (ParticleComponentStateDefinition stateDef : locationComponentDefinition.getComponentStateDefinitions()) {
if (stateDef.getName().equals(speciesPattern.getLocationName())) {
locationStateDefinition = stateDef;
}
}
ParticleComponentStatePattern locationStatePattern = new ParticleComponentStatePattern(locationStateDefinition);
locationPattern.setComponentStatePattern(locationStatePattern);
locationPattern.setBondType(ParticleBondType.None);
locationPattern.setBondId(-1);
molTypePattern.insertMolecularComponentPattern(0, locationPattern);
}
//
// add mark component to pattern ... state="0" (for observables and reactants ... later we will clone and use "1" for products).
{
final ParticleMolecularComponent markComponentDefinition = molTypePattern.getMolecularType().getComponentList().get(1);
ParticleMolecularComponentPattern markPattern = new ParticleMolecularComponentPattern(markComponentDefinition);
final int clearStateIndex = 0;
final int setStateIndex = 1;
ParticleComponentStateDefinition markStateClearedDefinition = markComponentDefinition.getComponentStateDefinitions().get(clearStateIndex);
ParticleComponentStatePattern markStatePattern = new ParticleComponentStatePattern(markStateClearedDefinition);
markPattern.setComponentStatePattern(markStatePattern);
markPattern.setBondType(ParticleBondType.None);
markPattern.setBondId(-1);
molTypePattern.insertMolecularComponentPattern(1, markPattern);
}
}
}
//
// when processing ParticleJumpProcesses, we add a new "product" species pattern (by cloning the original speciesPattern)
// and setting the mark site to "1", change name to name+"_PRODUCT", and add to math model if it doesn't already exist.
//
// cloned the "standard" reactant/observable speciesPattern, set the mark for all molecules, and add to mathDesc.
//
CompartmentSubDomain subDomain = (CompartmentSubDomain) clonedMathDesc.getSubDomains().nextElement();
for (ParticleJumpProcess particleJumpProcess : subDomain.getParticleJumpProcesses()) {
for (Action action : particleJumpProcess.getActions()) {
if (action.getOperation().equals(Action.ACTION_CREATE)) {
VolumeParticleSpeciesPattern volumeParticleSpeciesPattern = (VolumeParticleSpeciesPattern) action.getVar();
String newSpeciesPatternName = volumeParticleSpeciesPattern.getName() + "_" + particleJumpProcess.getName();
VolumeParticleSpeciesPattern productPattern = new VolumeParticleSpeciesPattern(volumeParticleSpeciesPattern, newSpeciesPatternName);
// VolumeParticleSpeciesPattern productPattern = (VolumeParticleSpeciesPattern) BeanUtils.cloneSerializable(volumeParticleSpeciesPattern);
for (ParticleMolecularTypePattern productMolTypePattern : productPattern.getParticleMolecularTypePatterns()) {
ParticleComponentStateDefinition markSet = productMolTypePattern.getMolecularType().getComponentList().get(1).getComponentStateDefinitions().get(1);
productMolTypePattern.getMolecularComponentPatternList().get(1).setComponentStatePattern(new ParticleComponentStatePattern(markSet));
}
System.out.println(productPattern.getName());
if (clonedMathDesc.getVariable(productPattern.getName()) == null) {
clonedMathDesc.addVariable(productPattern);
}
action.setVar(productPattern);
}
}
}
try {
System.out.println("===============================\n ----------- VCML HACKED .... START\n" + clonedMathDesc.getVCML_database() + "\nVCML HACKED .... END\n====================\n");
} catch (MathException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
} catch (Exception e) {
throw new SolverException("failed to apply location mark transformation: " + e.getMessage(), e);
}
}
Element sbmlElement = new Element("sbml");
Element modelElement = new Element("model");
modelElement.setAttribute("id", "nameless");
SimulationSymbolTable simulationSymbolTable = new SimulationSymbolTable(clonedSimTask.getSimulation(), clonedSimTask.getSimulationJob().getJobIndex());
Element listOfParametersElement = getListOfParameters(clonedMathDesc, simulationSymbolTable);
Element listOfMoleculeTypesElement = getListOfMoleculeTypes(clonedMathDesc);
Element listOfSpeciesElement = getListOfSpecies(clonedMathDesc, simulationSymbolTable);
CompartmentSubDomain compartmentSubDomain = (CompartmentSubDomain) clonedMathDesc.getSubDomains().nextElement();
Element listOfReactionRules = new Element("ListOfReactionRules");
for (int reactionRuleIndex = 0; reactionRuleIndex < compartmentSubDomain.getParticleJumpProcesses().size(); reactionRuleIndex++) {
ParticleJumpProcess particleJumpProcess = compartmentSubDomain.getParticleJumpProcesses().get(reactionRuleIndex);
MathRuleFactory mathRuleFactory = new MathRuleFactory();
MathRuleEntry rule = mathRuleFactory.createRuleEntry(particleJumpProcess, reactionRuleIndex);
RuleAnalysisReport report = RuleAnalysis.analyze(rule, true);
// remember, we have to add RateLaw
Element reactionRuleElement = RuleAnalysis.getNFSimXML(rule, report);
// ArrayList<MolecularTypeOfReactionParticipant> currentReactantElementsOfReaction = new ArrayList<MolecularTypeOfReactionParticipant>();
// ArrayList<ComponentOfMolecularTypeOfReactionParticipant> currentComponentOfReactantElementsOfReaction = new ArrayList<ComponentOfMolecularTypeOfReactionParticipant>();
// ArrayList<MolecularTypeOfReactionParticipant> currentProductElementsOfReaction = new ArrayList<MolecularTypeOfReactionParticipant>();
// ArrayList<ComponentOfMolecularTypeOfReactionParticipant> currentComponentOfProductElementsOfReaction = new ArrayList<ComponentOfMolecularTypeOfReactionParticipant>();
// currentMappingOfReactionParticipants.clear();
// reactionProductBondSites.clear();
// reactionReactantBondSites.clear();
//
// Element reactionRuleElement = new Element("ReactionRule");
// String reactionRuleID = "RR" + (reactionRuleIndex + 1);
// reactionRuleElement.setAttribute("id",reactionRuleID);
// reactionRuleElement.setAttribute("name",particleJumpProcess.getName());
// reactionRuleElement.setAttribute("symmetry_factor","1");
// reactionRule.resolveBonds();
//
// ArrayList<VolumeParticleSpeciesPattern> selectedPatterns = new ArrayList<VolumeParticleSpeciesPattern>();
// for (ParticleVariable particleVariable : particleJumpProcess.getParticleVariables()){
// if (!(particleVariable instanceof VolumeParticleSpeciesPattern)){
// throw new SolverException("expecting only "+VolumeParticleSpeciesPattern.class.getSimpleName()+"s for "+ParticleJumpProcess.class.getSimpleName()+" "+particleJumpProcess.getName());
// }
// selectedPatterns.add((VolumeParticleSpeciesPattern) particleVariable);
// }
// ArrayList<VolumeParticleSpeciesPattern> createdPatterns = new ArrayList<VolumeParticleSpeciesPattern>();
// HashSet<VolumeParticleSpeciesPattern> destroyedPatterns = new HashSet<VolumeParticleSpeciesPattern>();
// for (Action action : particleJumpProcess.getActions()){
// if (!(action.getVar() instanceof VolumeParticleSpeciesPattern)){
// throw new SolverException("expecting only "+VolumeParticleSpeciesPattern.class.getSimpleName()+"s for "+ParticleJumpProcess.class.getSimpleName()+" "+particleJumpProcess.getName());
// }
// if (action.getOperation().equals(Action.ACTION_CREATE)){
// createdPatterns.add((VolumeParticleSpeciesPattern) action.getVar());
// }else if (action.getOperation().equals(Action.ACTION_DESTROY)){
// destroyedPatterns.add((VolumeParticleSpeciesPattern) action.getVar());
// }else{
// throw new RuntimeException("unexpected action operation "+action.getOperation()+" for jump process "+particleJumpProcess.getName());
// }
// }
//
// Element listOfReactantPatternsElement = new Element("ListOfReactantPatterns");
// for(int reactantPatternIndex=0; reactantPatternIndex < selectedPatterns.size(); reactantPatternIndex++) {
// VolumeParticleSpeciesPattern reactantSpeciesPattern = selectedPatterns.get(reactantPatternIndex);
// String reactantPatternID = "RP" + (reactantPatternIndex + 1);
// patternReactantBondSites.clear();
// Element reactantPatternElement = getReactionParticipantPattern1(reactionRuleID, reactantPatternID, reactantSpeciesPattern,
// currentReactantElementsOfReaction, currentComponentOfReactantElementsOfReaction, "ReactantPattern");
// listOfReactantPatternsElement.addContent(reactantPatternElement);
// reactionReactantBondSites.addAll(patternReactantBondSites);
// }
// reactionRuleElement.addContent(listOfReactantPatternsElement);
//
// Element listOfProductPatternsElement = new Element("ListOfProductPatterns");
// ArrayList<VolumeParticleSpeciesPattern> productSpeciesPatterns = new ArrayList<VolumeParticleSpeciesPattern>(selectedPatterns);
// productSpeciesPatterns.removeAll(destroyedPatterns);
// productSpeciesPatterns.addAll(createdPatterns);
// // for products, add all "created" species from Actions and all "particles" that are selected but not destroyed
// for(int productPatternIndex=0; productPatternIndex < productSpeciesPatterns.size(); productPatternIndex++) {
// VolumeParticleSpeciesPattern productSpeciesPattern = productSpeciesPatterns.get(productPatternIndex);
// String productPatternID = "PP" + (productPatternIndex + 1);
// patternProductBondSites.clear();
// Element productPatternElement = getReactionParticipantPattern1(reactionRuleID, productPatternID, productSpeciesPattern,
// currentProductElementsOfReaction, currentComponentOfProductElementsOfReaction, "ProductPattern");
// listOfProductPatternsElement.addContent(productPatternElement);
// reactionProductBondSites.addAll(patternProductBondSites);
// }
// reactionRuleElement.addContent(listOfProductPatternsElement);
// <RateLaw id="RR1_RateLaw" type="Ele" totalrate="0">
// <ListOfRateConstants>
// <RateConstant value="kon"/>
// </ListOfRateConstants>
// </RateLaw>
Element rateLawElement = new Element("RateLaw");
rateLawElement.setAttribute("id", RuleAnalysis.getID(rule));
String rateConstantValue = null;
JumpProcessRateDefinition particleProbabilityRate = particleJumpProcess.getParticleRateDefinition();
if (particleProbabilityRate.getExpressions().length > 0) {
JumpProcessRateDefinition particleRateDefinition = particleJumpProcess.getParticleRateDefinition();
Expression expression = null;
if (particleRateDefinition instanceof MacroscopicRateConstant) {
expression = ((MacroscopicRateConstant) particleProbabilityRate).getExpression();
} else {
throw new SolverException("ParticleRateDefinition type " + particleRateDefinition.getClass().getSimpleName() + " not supported");
}
rateConstantValue = expression.infixBng();
// all rates constants are being flattened and given reserved names
Expression substitutedValExpr = null;
try {
substitutedValExpr = simulationSymbolTable.substituteFunctions(expression);
} catch (MathException | ExpressionException e) {
e.printStackTrace(System.out);
throw new SolverException("ParticleJumpProcess " + particleJumpProcess.getName() + " substitution failed : exp = \"" + expression.infix() + "\": " + e.getMessage());
}
Double value = null;
try {
value = substitutedValExpr.evaluateConstant();
Element parameterElement = new Element("Parameter");
String id = "K_reserved_" + reactionRuleIndex;
parameterElement.setAttribute("id", id);
if (value != null) {
parameterElement.setAttribute("type", "Constant");
parameterElement.setAttribute("value", value.toString());
parameterElement.addContent(new Comment(rateConstantValue));
rateConstantValue = id;
listOfParametersElement.addContent(parameterElement);
}
} catch (ExpressionException e) {
System.out.println("ParticleJumpProcess " + particleJumpProcess.getName() + " = " + substitutedValExpr.infix() + " does not have a constant value");
}
}
if (isFunction(rateConstantValue, clonedMathDesc, simulationSymbolTable)) {
rateLawElement.setAttribute("type", "Function");
rateLawElement.setAttribute("totalrate", "0");
rateLawElement.setAttribute("name", rateConstantValue);
} else {
rateLawElement.setAttribute("type", "Ele");
rateLawElement.setAttribute("totalrate", "0");
Element listOfRateConstantsElement = new Element("ListOfRateConstants");
Element rateConstantElement = new Element("RateConstant");
// System.out.println(" --- " + particleJumpProcess.getParticleRateDefinition().getExpressions());
if (particleProbabilityRate.getExpressions().length > 0) {
rateConstantElement.setAttribute("value", rateConstantValue);
}
listOfRateConstantsElement.addContent(rateConstantElement);
rateLawElement.addContent(listOfRateConstantsElement);
}
reactionRuleElement.addContent(rateLawElement);
// // <Map>
// // <MapItem sourceID="RR1_RP1_M1" targetID="RR1_PP1_M1"/>
// // <MapItem sourceID="RR1_RP1_M1_C1" targetID="RR1_PP1_M1_C1"/>
// // <MapItem sourceID="RR1_RP1_M1_C2" targetID="RR1_PP1_M1_C2"/>
// // <MapItem sourceID="RR1_RP2_M1" targetID="RR1_PP1_M2"/>
// // <MapItem sourceID="RR1_RP2_M1_C1" targetID="RR1_PP1_M2_C1"/>
// // </Map>
// Element mapElement = new Element("Map");
// System.out.println("----------------------------------------------------------------------");
// for(MolecularTypeOfReactionParticipant p : currentReactantElementsOfReaction) {
// System.out.println(p.moleculeName + ", " + p.elementID);
// }
// for(ComponentOfMolecularTypeOfReactionParticipant c : currentComponentOfReactantElementsOfReaction) {
// System.out.println(c.moleculeName + ", " + c.componentName + ", " + c.elementID);
// }
// System.out.println("----------------------------------------------------------------------");
// for(MolecularTypeOfReactionParticipant p : currentProductElementsOfReaction) {
// System.out.println(p.moleculeName + ", " + p.elementID);
// }
// for(ComponentOfMolecularTypeOfReactionParticipant c : currentComponentOfProductElementsOfReaction) {
// System.out.println(c.moleculeName + ", " + c.componentName + ", " + c.elementID);
// }
// System.out.println("----------------------------------------------------------------------");
//
// List<MolecularTypeOfReactionParticipant> cloneOfReactants = new ArrayList<MolecularTypeOfReactionParticipant>(currentReactantElementsOfReaction);
// List<MolecularTypeOfReactionParticipant> cloneOfProducts = new ArrayList<MolecularTypeOfReactionParticipant>(currentProductElementsOfReaction);
// for(Iterator<MolecularTypeOfReactionParticipant> itReactant = cloneOfReactants.iterator(); itReactant.hasNext();) { // participants
// MolecularTypeOfReactionParticipant reactant = itReactant.next();
// boolean foundProduct = false;
// for(Iterator<MolecularTypeOfReactionParticipant> itProduct = cloneOfProducts.iterator(); itProduct.hasNext();) {
// MolecularTypeOfReactionParticipant product = itProduct.next();
// if(reactant.find(product)) {
// MappingOfReactionParticipants m = new MappingOfReactionParticipants(reactant.elementID, product.elementID, "");
// currentMappingOfReactionParticipants.add(m );
// itProduct.remove();
// foundProduct = true;
// break; // we exit inner loop if we find a match for current reactant
// }
// }
// if(foundProduct == false) {
// System.out.println("Did not found a match for reactant " + reactant.moleculeName + ", " + reactant.elementID);
// }
// itReactant.remove(); // found or not, we remove the reactant
// }
// if(!currentProductElementsOfReaction.isEmpty()) {
// for(MolecularTypeOfReactionParticipant p : currentProductElementsOfReaction) {
// System.out.println("Did not found a match for product " + p.moleculeName + ", " + p.elementID);
// }
// }
// for(Iterator<ComponentOfMolecularTypeOfReactionParticipant> itReactant = currentComponentOfReactantElementsOfReaction.iterator(); itReactant.hasNext();) { // components
// ComponentOfMolecularTypeOfReactionParticipant reactant = itReactant.next();
// boolean foundProduct = false;
// for(Iterator<ComponentOfMolecularTypeOfReactionParticipant> itProduct = currentComponentOfProductElementsOfReaction.iterator(); itProduct.hasNext();) {
// ComponentOfMolecularTypeOfReactionParticipant product = itProduct.next();
// String state = "";
// if(reactant.find(product)) {
// if(!reactant.state.equals(product.state)) {
// state = product.state;
// }
// MappingOfReactionParticipants m = new MappingOfReactionParticipants(reactant.elementID, product.elementID, state);
// currentMappingOfReactionParticipants.add(m );
// itProduct.remove();
// foundProduct = true;
// break; // we exit inner loop if we find a match for current reactant
// }
// }
// if(foundProduct == false) {
// System.out.println("Did not found a match for reactant " + reactant.moleculeName + ", " + reactant.elementID);
// }
// itReactant.remove(); // found or not, we remove the reactant
// }
// if(!currentComponentOfProductElementsOfReaction.isEmpty()) {
// for(ComponentOfMolecularTypeOfReactionParticipant p : currentComponentOfProductElementsOfReaction) {
// System.out.println("Did not found a match for product " + p.moleculeName + ", " + p.elementID);
// }
// }
// for(Iterator<MappingOfReactionParticipants> it = currentMappingOfReactionParticipants.iterator(); it.hasNext();) {
// MappingOfReactionParticipants m = it.next();
// Element mapItemElement = new Element("MapItem");
// mapItemElement.setAttribute("sourceID", m.reactantElementID);
// mapItemElement.setAttribute("targetID", m.productElementID);
// mapElement.addContent(mapItemElement);
// }
// reactionRuleElement.addContent(mapElement);
//
// // <ListOfOperations>
// // <AddBond site1="RR1_RP1_M1_C1" site2="RR1_RP2_M1_C1"/>
// // <StateChange site="RR0_RP0_M0_C2" finalState="Y"/>
// // </ListOfOperations>
// Element listOfOperationsElement = new Element("ListOfOperations");
//
// // AddBond elements
// // add any bond in the product which is not present in the reactant
// Iterator<BondSites> it = patternProductBondSites.iterator();
// while (it.hasNext()) {
// BondSites bs = it.next();
// String reactantS1 = MappingOfReactionParticipants.findMatchingReactant(bs.component1, currentMappingOfReactionParticipants);
// String reactantS2 = MappingOfReactionParticipants.findMatchingReactant(bs.component2, currentMappingOfReactionParticipants);
// // we check if the bonds in the product existed already in the reactant, in which case they were not "added" in this reaction
// BondSites candidate = new BondSites(reactantS1, reactantS2);
// boolean preExistent = false;
// for(BondSites bsReactant : reactionReactantBondSites) {
// if(bsReactant.equals(candidate)) {
// preExistent = true;
// break;
// }
// }
// if(preExistent == true) {
// continue; // we don't add preexisting bonds
// }
// Element addBondElement = new Element("AddBond");
// addBondElement.setAttribute("site1", reactantS1);
// addBondElement.setAttribute("site2", reactantS2);
// listOfOperationsElement.addContent(addBondElement);
// }
// // StateChange elements
// for(Iterator<MappingOfReactionParticipants> it1 = currentMappingOfReactionParticipants.iterator(); it1.hasNext();) {
// MappingOfReactionParticipants m = it1.next();
// if(!m.componentFinalState.equals("")) { // state has changed if it's different from ""
// Element stateChangeElement = new Element("StateChange");
// stateChangeElement.setAttribute("site", m.reactantElementID);
// stateChangeElement.setAttribute("finalState", m.componentFinalState);
// listOfOperationsElement.addContent(stateChangeElement);
// }
// }
// // eliminate all the common entries (molecule types) in reactants and products
// // what's left in reactants was deleted, what's left in products was added
// List<MolecularTypeOfReactionParticipant> commonParticipants = new ArrayList<MolecularTypeOfReactionParticipant>();
// for(Iterator<MolecularTypeOfReactionParticipant> itReactant = currentReactantElementsOfReaction.iterator(); itReactant.hasNext();) { // participants
// MolecularTypeOfReactionParticipant reactant = itReactant.next();
// for(Iterator<MolecularTypeOfReactionParticipant> itProduct = currentProductElementsOfReaction.iterator(); itProduct.hasNext();) {
// MolecularTypeOfReactionParticipant product = itProduct.next();
// if(reactant.find(product)) {
// // commonParticipants contains the reactant molecules with a equivalent molecule in the product (meaning they are not in the "Deleted" category)
// commonParticipants.add(reactant);
// itReactant.remove();
// itProduct.remove();
// break; // we exit inner loop if we find a match for current reactant
// }
// }
// }
// // DeleteBond element
// // there is no need to mention deletion of bond if the particleSpeciesPattern
// // or the MolecularType involved in the bond are deleted as well
// // We only keep those "Deleted" bonds which belong to the molecules (of the reactant) present in commonParticipants
// // Both components (sites) of the bond need to have their molecules in commonParticipants
// boolean foundMoleculeForComponent1 = false;
// boolean foundMoleculeForComponent2 = false;
// HashSet<BondSites> cloneOfReactantBondSites = new HashSet<BondSites>(patternReactantBondSites);
// Iterator<BondSites> itbs = cloneOfReactantBondSites.iterator();
// while (itbs.hasNext()) {
// BondSites bs = itbs.next();
// String bondComponent1MoleculeId = BondSites.extractMoleculeId(bs.component1);
// String bondComponent2MoleculeId = BondSites.extractMoleculeId(bs.component2);
// for(MolecularTypeOfReactionParticipant commonReactionMoleculeule : commonParticipants) {
// String commonReactantPatternId = commonReactionMoleculeule.elementID;
// if(bondComponent1MoleculeId.equals(commonReactantPatternId)) {
// foundMoleculeForComponent1 = true;
// }
// if(bondComponent2MoleculeId.equals(commonReactantPatternId)) {
// foundMoleculeForComponent2 = true;
// }
// }
// if(!foundMoleculeForComponent1 || !foundMoleculeForComponent2) {
// // at least one of bond's molecule is not in common, hence we don't need to report the deletion of this bond
// itbs.remove();
// }
// }
// // the clone has now all the deleted bonds whose molecules have not been deleted
// itbs = cloneOfReactantBondSites.iterator();
// while (itbs.hasNext()) {
// BondSites bs = itbs.next();
// Element addBondElement = new Element("DeleteBond");
// addBondElement.setAttribute("site1", bs.component1);
// addBondElement.setAttribute("site2", bs.component2);
// listOfOperationsElement.addContent(addBondElement);
// }
// // Add MolecularType element
// for(MolecularTypeOfReactionParticipant molecule : currentProductElementsOfReaction) {
// System.out.println("created molecule: " + molecule.elementID + "' " + molecule.moleculeName);
// Element addMolecularTypePatternElement = new Element("Add");
// addMolecularTypePatternElement.setAttribute("id", molecule.elementID);
// listOfOperationsElement.addContent(addMolecularTypePatternElement);
// }
// // Delete MolecularType element
// // if the reactant pattern of the molecule being deleted still exists as part of the common, then we only delete the molecule
// // if the reactant pattern of the molecule being deleted is not as part of the common, then it's gone completely and we delete the reactant pattern
// ArrayList<String> patternsToDelete = new ArrayList<String>();
// for(MolecularTypeOfReactionParticipant molecule : currentReactantElementsOfReaction) {
// String reactantPatternId = molecule.extractReactantPatternId();
// boolean found = false;
// for(MolecularTypeOfReactionParticipant common : commonParticipants) {
// String commonId = common.extractReactantPatternId();
// if(reactantPatternId.equals(commonId)) {
// found = true;
// break; // some other molecule of this pattern still there, we don't delete the pattern
// }
// }
// if(found == true) { // some other molecule of this pattern still there, we don't delete the pattern
// System.out.println("deleted molecule: " + molecule.elementID + "' " + molecule.moleculeName);
// Element addMolecularTypePatternElement = new Element("Delete");
// addMolecularTypePatternElement.setAttribute("id", molecule.elementID);
// addMolecularTypePatternElement.setAttribute("DeleteMolecules", "0");
// listOfOperationsElement.addContent(addMolecularTypePatternElement);
// } else { // no molecule of this pattern left, we delete the pattern
// if(patternsToDelete.contains(reactantPatternId)) {
// // nothing to do, we're already deleting this pattern
// break;
// } else {
// patternsToDelete.add(reactantPatternId);
// System.out.println("deleted pattern: " + reactantPatternId);
// Element addParticleSpeciesPatternElement = new Element("Delete");
// addParticleSpeciesPatternElement.setAttribute("id", reactantPatternId);
// addParticleSpeciesPatternElement.setAttribute("DeleteMolecules", "0");
// listOfOperationsElement.addContent(addParticleSpeciesPatternElement);
// }
// }
// }
// reactionRuleElement.addContent(listOfOperationsElement);
listOfReactionRules.addContent(reactionRuleElement);
}
Element listOfObservablesElement = getListOfObservables(clonedMathDesc);
Element listOfFunctionsElement = getListOfFunctions(clonedMathDesc, simulationSymbolTable);
modelElement.addContent(listOfParametersElement);
modelElement.addContent(listOfMoleculeTypesElement);
modelElement.addContent(listOfSpeciesElement);
modelElement.addContent(listOfReactionRules);
modelElement.addContent(listOfObservablesElement);
modelElement.addContent(listOfFunctionsElement);
sbmlElement.addContent(modelElement);
// // return e1;
return sbmlElement;
}
use of cbit.vcell.math.ParticleMolecularType in project vcell by virtualcell.
the class Xmlproducer method getXML.
/**
* This method returns a XML representation of a MathDescription object.
* Creation date: (3/2/2001 10:57:25 AM)
* @return Element
* @param mathdes cbit.vcell.math.MathDescription
*/
Element getXML(MathDescription mathdes) throws XmlParseException {
Element math = new Element(XMLTags.MathDescriptionTag);
// Add attributes
math.setAttribute(XMLTags.NameAttrTag, mangle(mathdes.getName()));
// Add annotation
if (mathdes.getDescription() != null && mathdes.getDescription().length() > 0) {
Element annotationElem = new Element(XMLTags.AnnotationTag);
annotationElem.setText(mangle(mathdes.getDescription()));
math.addContent(annotationElem);
}
List<ParticleMolecularType> particleMolecularTypes = mathdes.getParticleMolecularTypes();
for (ParticleMolecularType particleMolecularType : particleMolecularTypes) {
math.addContent(getXML(particleMolecularType));
}
// Add Constant subelements
Enumeration<Variable> enum1 = mathdes.getVariables();
/*java.util.Iterator k;
try {
VariableHash varHash = new VariableHash();
while (enum1.hasMoreElements())
varHash.addVariable((Variable)enum1.nextElement());
Variable vars [] = varHash.getReorderedVariables();
k = new ArrayList(java.util.Arrays.asList(vars)).iterator();
} catch (cbit.vcell.mapping.MappingException e) {
e.printStackTrace();
return null;
}*/
while (enum1.hasMoreElements()) {
Variable var = enum1.nextElement();
Element element = null;
if (var instanceof Constant) {
element = getXML((Constant) var);
} else if (var instanceof FilamentRegionVariable) {
element = getXML((FilamentRegionVariable) var);
} else if (var instanceof FilamentVariable) {
element = getXML((FilamentVariable) var);
} else if (var instanceof PointVariable) {
element = getXML((PointVariable) var);
} else if (var instanceof Function) {
element = getXML((Function) var);
} else if (var instanceof RandomVariable) {
element = getXML((RandomVariable) var);
} else if (var instanceof InsideVariable) {
// *** for internal use! Ignore it ***
continue;
} else if (var instanceof MembraneRegionVariable) {
element = getXML((MembraneRegionVariable) var);
} else if (var instanceof MemVariable) {
element = getXML((MemVariable) var);
} else if (var instanceof OutsideVariable) {
// *** for internal use! Ignore it ****
continue;
} else if (var instanceof VolumeRegionVariable) {
element = getXML((VolumeRegionVariable) var);
} else if (var instanceof VolVariable) {
element = getXML((VolVariable) var);
} else if (var instanceof StochVolVariable) {
// added for stochastic volumn variables
element = getXML((StochVolVariable) var);
} else if (var instanceof ParticleVariable) {
element = getXML((ParticleVariable) var);
} else if (var instanceof ParticleObservable) {
element = getXML((ParticleObservable) var);
} else {
throw new XmlParseException("An unknown variable type " + var.getClass().getName() + " was found when parsing the mathdescription " + mathdes.getName() + "!");
}
transcribeComments(var, element);
math.addContent(element);
}
// this was moved to the simspec!
/* buffer.append("\n");
if (geometry != null){
buffer.append(geometry.getXML());
}
buffer.append("\n");*/
// Add subdomains
Enumeration<SubDomain> enum2 = mathdes.getSubDomains();
while (enum2.hasMoreElements()) {
SubDomain subDomain = enum2.nextElement();
math.addContent(getXML(subDomain));
}
// Add Metadata (Version) if there is!
if (mathdes.getVersion() != null) {
math.addContent(getXML(mathdes.getVersion(), mathdes));
}
Iterator<Event> iter = mathdes.getEvents();
while (iter.hasNext()) {
math.addContent(getXML(iter.next()));
}
PostProcessingBlock postProcessingBlock = mathdes.getPostProcessingBlock();
if (postProcessingBlock.getNumDataGenerators() > 0) {
math.addContent(getXML(postProcessingBlock));
}
return math;
}
use of cbit.vcell.math.ParticleMolecularType in project vcell by virtualcell.
the class RulebasedMathMapping method addSpeciesPatterns.
private HashMap<SpeciesPattern, VolumeParticleSpeciesPattern> addSpeciesPatterns(Domain domain, List<ReactionRule> rrList) throws MathException {
// Particle Molecular Types
//
Model model = getSimulationContext().getModel();
List<RbmObservable> observableList = model.getRbmModelContainer().getObservableList();
List<MolecularType> molecularTypeList = model.getRbmModelContainer().getMolecularTypeList();
for (MolecularType molecularType : molecularTypeList) {
ParticleMolecularType particleMolecularType = new ParticleMolecularType(molecularType.getName());
for (MolecularComponent molecularComponent : molecularType.getComponentList()) {
String pmcName = molecularComponent.getName();
String pmcId = particleMolecularType.getName() + "_" + molecularComponent.getName();
ParticleMolecularComponent particleMolecularComponent = new ParticleMolecularComponent(pmcId, pmcName);
for (ComponentStateDefinition componentState : molecularComponent.getComponentStateDefinitions()) {
ParticleComponentStateDefinition pcsd = particleMolecularComponent.getComponentStateDefinition(componentState.getName());
if (pcsd == null) {
particleMolecularComponent.addComponentStateDefinition(new ParticleComponentStateDefinition(componentState.getName()));
}
}
particleMolecularType.addMolecularComponent(particleMolecularComponent);
}
if (!molecularType.isAnchorAll()) {
List<String> anchorList = new ArrayList<>();
for (Structure struct : molecularType.getAnchors()) {
anchorList.add(struct.getName());
}
particleMolecularType.setAnchorList(anchorList);
}
mathDesc.addParticleMolecularType(particleMolecularType);
}
//
// Assemble list of all Species Patterns (from observables, reaction rules, and seed species).
//
// linked hash set maintains insertion order
LinkedHashMap<SpeciesPattern, Structure> speciesPatternStructureMap = new LinkedHashMap<SpeciesPattern, Structure>();
for (RbmObservable observable : observableList) {
for (SpeciesPattern speciesPattern : observable.getSpeciesPatternList()) {
speciesPatternStructureMap.put(speciesPattern, observable.getStructure());
}
}
for (ReactionRule reactionRule : rrList) {
for (ReactantPattern rp : reactionRule.getReactantPatterns()) {
speciesPatternStructureMap.put(rp.getSpeciesPattern(), rp.getStructure());
}
for (ProductPattern pp : reactionRule.getProductPatterns()) {
speciesPatternStructureMap.put(pp.getSpeciesPattern(), pp.getStructure());
}
}
for (SpeciesContext sc : model.getSpeciesContexts()) {
if (!sc.hasSpeciesPattern()) {
continue;
}
speciesPatternStructureMap.put(sc.getSpeciesPattern(), sc.getStructure());
}
//
// add list of unique speciesPatterns
//
HashMap<String, VolumeParticleSpeciesPattern> speciesPatternVCMLMap = new HashMap<String, VolumeParticleSpeciesPattern>();
HashMap<SpeciesPattern, VolumeParticleSpeciesPattern> speciesPatternMap = new HashMap<SpeciesPattern, VolumeParticleSpeciesPattern>();
String speciesPatternName = "speciesPattern0";
for (SpeciesPattern speciesPattern : speciesPatternStructureMap.keySet()) {
VolumeParticleSpeciesPattern volumeParticleSpeciesPattern = new VolumeParticleSpeciesPattern(speciesPatternName, domain, speciesPatternStructureMap.get(speciesPattern).getName());
for (MolecularTypePattern molecularTypePattern : speciesPattern.getMolecularTypePatterns()) {
ParticleMolecularType particleMolecularType = mathDesc.getParticleMolecularType(molecularTypePattern.getMolecularType().getName());
ParticleMolecularTypePattern particleMolecularTypePattern = new ParticleMolecularTypePattern(particleMolecularType);
String participantMatchLabel = molecularTypePattern.getParticipantMatchLabel();
if (molecularTypePattern.getParticipantMatchLabel() != null) {
particleMolecularTypePattern.setMatchLabel(participantMatchLabel);
}
for (MolecularComponentPattern molecularComponentPattern : molecularTypePattern.getComponentPatternList()) {
MolecularComponent molecularComponent = molecularComponentPattern.getMolecularComponent();
ParticleMolecularComponent particleMolecularComponent = particleMolecularType.getMolecularComponent(molecularComponent.getName());
ParticleMolecularComponentPattern particleMolecularComponentPattern = new ParticleMolecularComponentPattern(particleMolecularComponent);
ComponentStatePattern componentState = molecularComponentPattern.getComponentStatePattern();
if (componentState != null) {
if (componentState.isAny()) {
ParticleComponentStatePattern pcsp = new ParticleComponentStatePattern();
particleMolecularComponentPattern.setComponentStatePattern(pcsp);
} else {
String name = componentState.getComponentStateDefinition().getName();
ParticleComponentStateDefinition pcsd = particleMolecularComponent.getComponentStateDefinition(name);
// ParticleComponentStateDefinition pcsd = new ParticleComponentStateDefinition(componentState.getComponentStateDefinition().getName());
// particleMolecularComponent.addComponentStateDefinition(pcsd);
ParticleComponentStatePattern pcsp = new ParticleComponentStatePattern(pcsd);
particleMolecularComponentPattern.setComponentStatePattern(pcsp);
}
} else {
ParticleComponentStatePattern pcsp = new ParticleComponentStatePattern();
particleMolecularComponentPattern.setComponentStatePattern(pcsp);
}
switch(molecularComponentPattern.getBondType()) {
case Specified:
{
particleMolecularComponentPattern.setBondType(ParticleBondType.Specified);
particleMolecularComponentPattern.setBondId(molecularComponentPattern.getBondId());
break;
}
case Exists:
{
particleMolecularComponentPattern.setBondType(ParticleBondType.Exists);
particleMolecularComponentPattern.setBondId(-1);
break;
}
case None:
{
particleMolecularComponentPattern.setBondType(ParticleBondType.None);
particleMolecularComponentPattern.setBondId(-1);
break;
}
case Possible:
{
particleMolecularComponentPattern.setBondType(ParticleBondType.Possible);
particleMolecularComponentPattern.setBondId(-1);
break;
}
}
particleMolecularTypePattern.addMolecularComponentPattern(particleMolecularComponentPattern);
}
volumeParticleSpeciesPattern.addMolecularTypePattern(particleMolecularTypePattern);
}
String speciesPatternVCML = volumeParticleSpeciesPattern.getVCML("tempName");
VolumeParticleSpeciesPattern uniqueVolumeParticleSpeciesPattern = speciesPatternVCMLMap.get(speciesPatternVCML);
if (uniqueVolumeParticleSpeciesPattern == null) {
speciesPatternVCMLMap.put(speciesPatternVCML, volumeParticleSpeciesPattern);
speciesPatternName = TokenMangler.getNextEnumeratedToken(speciesPatternName);
speciesPatternMap.put(speciesPattern, volumeParticleSpeciesPattern);
} else {
speciesPatternMap.put(speciesPattern, uniqueVolumeParticleSpeciesPattern);
}
}
return speciesPatternMap;
}
use of cbit.vcell.math.ParticleMolecularType in project vcell by virtualcell.
the class XmlReader method getParticleMolecularType.
private ParticleMolecularType getParticleMolecularType(Element param) {
String name = unMangle(param.getAttributeValue(XMLTags.NameAttrTag));
ParticleMolecularType var = new ParticleMolecularType(name);
List<Element> molecularComponentList = param.getChildren(XMLTags.ParticleMolecularComponentPatternTag, vcNamespace);
for (Element molecularComponent : molecularComponentList) {
ParticleMolecularComponent p = getParticleMolecularComponent(name, molecularComponent);
var.addMolecularComponent(p);
}
List<Element> anchorList = param.getChildren(XMLTags.ParticleMolecularTypeAnchorTag, vcNamespace);
for (Element anchorElement : anchorList) {
String anchor = unMangle(anchorElement.getAttributeValue(XMLTags.NameAttrTag));
var.addAnchor(anchor);
}
return var;
}
Aggregations