use of org.vcell.util.CommentStringTokenizer in project vcell by virtualcell.
the class OutputTimeSpec method readVCML.
/**
* Insert the method's description here.
* Creation date: (9/7/2005 9:10:09 AM)
* @return cbit.vcell.solver.OutputTimeSpec
*/
public static OutputTimeSpec readVCML(CommentStringTokenizer tokens) throws DataAccessException {
//
// read format as follows:
//
// OutputOptions {
// KeepEvery 1
// KeepAtMost 1000
// }
//
// OR
// OutputOptions {
// OutputTimes 0.1,0.3,0.4,... (no spaces or line feeds between numbers)
// }
//
// OR
// OutputOptions {
// OutputTimeStep 10
// }
//
OutputTimeSpec ots = null;
try {
String token = tokens.nextToken();
if (token.equalsIgnoreCase(VCML.OutputOptions)) {
token = tokens.nextToken();
}
if (!token.equalsIgnoreCase(VCML.BeginBlock)) {
throw new DataAccessException("unexpected token " + token + " expecting " + VCML.BeginBlock);
}
while (tokens.hasMoreTokens()) {
token = tokens.nextToken();
if (token.equalsIgnoreCase(VCML.EndBlock)) {
break;
}
if (token.equalsIgnoreCase(VCML.KeepEvery)) {
token = tokens.nextToken();
int keepEvery = Integer.parseInt(token);
token = tokens.nextToken();
if (!token.equalsIgnoreCase(VCML.KeepAtMost)) {
throw new DataAccessException("unexpected identifier " + token);
}
token = tokens.nextToken();
int keepAtMost = Integer.parseInt(token);
ots = new DefaultOutputTimeSpec(keepEvery, keepAtMost);
continue;
} else if (token.equalsIgnoreCase(VCML.OutputTimeStep)) {
token = tokens.nextToken();
double outputTimeStep = Double.parseDouble(token);
ots = new UniformOutputTimeSpec(outputTimeStep);
continue;
} else if (token.equalsIgnoreCase(VCML.OutputTimes)) {
token = tokens.nextToken();
java.util.StringTokenizer st = new java.util.StringTokenizer(token, ",");
double[] times = new double[st.countTokens()];
int count = 0;
while (st.hasMoreTokens()) {
token = st.nextToken();
times[count++] = Double.parseDouble(token);
}
ots = new ExplicitOutputTimeSpec(times);
continue;
}
throw new DataAccessException("unexpected identifier " + token);
}
} catch (Throwable e) {
throw new DataAccessException("line #" + (tokens.lineIndex() + 1) + " Exception: " + e.getMessage());
}
return ots;
}
use of org.vcell.util.CommentStringTokenizer in project vcell by virtualcell.
the class ParticleDataBlock method readParticleData.
private void readParticleData(List<String> lines) throws DataAccessException {
String lastSpecies = null;
List<Coordinate> working = null;
for (String line : lines) {
try {
CommentStringTokenizer st = new CommentStringTokenizer(line);
String sp = st.nextToken();
if (!sp.equals(lastSpecies)) {
lastSpecies = sp;
working = fetch(sp);
}
double x = Double.parseDouble(st.nextToken());
double y = Double.parseDouble(st.nextToken());
double z = Double.parseDouble(st.nextToken());
Coordinate c = new Coordinate(x, y, z);
working.add(c);
} catch (Exception exc) {
throw new DataAccessException("Particle data file invalid. " + exc.getMessage());
}
}
}
use of org.vcell.util.CommentStringTokenizer in project vcell by virtualcell.
the class ParameterEstimationTaskXMLPersistence method getParameterEstimationTask.
/**
* Insert the method's description here.
* Creation date: (5/5/2006 4:50:36 PM)
* @return cbit.vcell.modelopt.ParameterEstimationTask
* @param element org.jdom.Element
* @param simContext cbit.vcell.mapping.SimulationContext
*/
public static ParameterEstimationTask getParameterEstimationTask(Element parameterEstimationTaskElement, SimulationContext simContext) throws ExpressionException, MappingException, MathException, java.beans.PropertyVetoException {
Namespace ns = parameterEstimationTaskElement.getNamespace();
ParameterEstimationTask parameterEstimationTask = new ParameterEstimationTask(simContext);
String name = parameterEstimationTaskElement.getAttributeValue(NameAttribute);
parameterEstimationTask.setName(name);
Element annotationElement = parameterEstimationTaskElement.getChild(AnnotationTag, ns);
if (annotationElement != null) {
String annotationText = annotationElement.getText();
parameterEstimationTask.setAnnotation(annotationText);
}
//
// read ParameterMappingSpecs
//
Element parameterMappingSpecListElement = parameterEstimationTaskElement.getChild(ParameterMappingSpecListTag, ns);
if (parameterMappingSpecListElement != null) {
List<Element> parameterMappingSpecElementList = parameterMappingSpecListElement.getChildren(ParameterMappingSpecTag, ns);
for (Element parameterMappingSpecElement : parameterMappingSpecElementList) {
String parameterName = parameterMappingSpecElement.getAttributeValue(ParameterReferenceAttribute);
SymbolTableEntry ste = getSymbolTableEntry(simContext, parameterName);
if (ste instanceof Parameter) {
Parameter parameter = (Parameter) ste;
ParameterMappingSpec parameterMappingSpec = parameterEstimationTask.getModelOptimizationSpec().getParameterMappingSpec(parameter);
if (parameterMappingSpec != null) {
String lowLimitString = parameterMappingSpecElement.getAttributeValue(LowLimitAttribute);
if (lowLimitString != null) {
parameterMappingSpec.setLow(parseDouble(lowLimitString));
}
String highLimitString = parameterMappingSpecElement.getAttributeValue(HighLimitAttribute);
if (highLimitString != null) {
parameterMappingSpec.setHigh(parseDouble(highLimitString));
}
String currentValueString = parameterMappingSpecElement.getAttributeValue(CurrentValueAttribute);
if (currentValueString != null) {
parameterMappingSpec.setCurrent(Double.parseDouble(currentValueString));
}
String selectedString = parameterMappingSpecElement.getAttributeValue(SelectedAttribute);
if (selectedString != null) {
parameterMappingSpec.setSelected(Boolean.valueOf(selectedString).booleanValue());
}
}
} else {
System.out.println("couldn't read parameterMappingSpec '" + parameterName + "', ste=" + ste);
}
}
}
//
// read ReferenceData
//
Element referenceDataElement = parameterEstimationTaskElement.getChild(ReferenceDataTag, ns);
if (referenceDataElement != null) {
String numRowsText = referenceDataElement.getAttributeValue(NumRowsAttribute);
String numColsText = referenceDataElement.getAttributeValue(NumColumnsAttribute);
// int numRows = Integer.parseInt(numRowsText);
int numCols = Integer.parseInt(numColsText);
//
// read columns
//
String[] columnNames = new String[numCols];
double[] columnWeights = new double[numCols];
int columnCounter = 0;
Element dataColumnListElement = referenceDataElement.getChild(DataColumnListTag, ns);
List<Element> dataColumnList = dataColumnListElement.getChildren(DataColumnTag, ns);
for (Element dataColumnElement : dataColumnList) {
columnNames[columnCounter] = dataColumnElement.getAttributeValue(NameAttribute);
columnWeights[columnCounter] = Double.parseDouble(dataColumnElement.getAttributeValue(WeightAttribute));
columnCounter++;
}
//
// read rows
//
Vector<double[]> rowDataVector = new Vector<double[]>();
Element dataRowListElement = referenceDataElement.getChild(DataRowListTag, ns);
List<Element> dataRowList = dataRowListElement.getChildren(DataRowTag, ns);
for (Element dataRowElement : dataRowList) {
String rowText = dataRowElement.getText();
CommentStringTokenizer tokens = new CommentStringTokenizer(rowText);
double[] rowData = new double[numCols];
for (int j = 0; j < numCols; j++) {
if (tokens.hasMoreTokens()) {
String token = tokens.nextToken();
rowData[j] = Double.parseDouble(token);
} else {
throw new RuntimeException("failed to read row data for ReferenceData");
}
}
rowDataVector.add(rowData);
}
ReferenceData referenceData = new SimpleReferenceData(columnNames, columnWeights, rowDataVector);
parameterEstimationTask.getModelOptimizationSpec().setReferenceData(referenceData);
}
//
// read ReferenceDataMappingSpecs
//
Element referenceDataMappingSpecListElement = parameterEstimationTaskElement.getChild(ReferenceDataMappingSpecListTag, ns);
if (referenceDataMappingSpecListElement != null) {
List<Element> referenceDataMappingSpecList = referenceDataMappingSpecListElement.getChildren(ReferenceDataMappingSpecTag, ns);
for (Element referenceDataMappingSpecElement : referenceDataMappingSpecList) {
String referenceDataColumnName = referenceDataMappingSpecElement.getAttributeValue(ReferenceDataColumnNameAttribute);
String referenceDataModelSymbolName = referenceDataMappingSpecElement.getAttributeValue(ReferenceDataModelSymbolAttribute);
ReferenceDataMappingSpec referenceDataMappingSpec = parameterEstimationTask.getModelOptimizationSpec().getReferenceDataMappingSpec(referenceDataColumnName);
SymbolTableEntry modelSymbolTableEntry = null;
if (referenceDataModelSymbolName != null) {
modelSymbolTableEntry = getSymbolTableEntry(simContext, referenceDataModelSymbolName);
if (referenceDataMappingSpec != null && modelSymbolTableEntry != null) {
referenceDataMappingSpec.setModelObject(modelSymbolTableEntry);
}
}
}
}
//
// read OptimizationSolverSpec
//
Element optimizationSolverSpecElement = parameterEstimationTaskElement.getChild(OptimizationSolverSpecTag, ns);
if (optimizationSolverSpecElement != null) {
OptimizationSolverSpec optSolverSpec = null;
String optimizationSolverTypeName = optimizationSolverSpecElement.getAttributeValue(OptimizationSolverTypeAttribute);
// getting parameters
Element optimizationSolverParameterList = optimizationSolverSpecElement.getChild(OptimizationListOfParametersTag, ns);
if (optimizationSolverParameterList != null) {
List<Element> listOfSolverParams = optimizationSolverParameterList.getChildren(OptimizationParameterTag, ns);
CopasiOptimizationMethod copasiOptMethod = null;
if (listOfSolverParams != null && listOfSolverParams.size() > 0) {
List<CopasiOptimizationParameter> copasiSolverParams = new ArrayList<CopasiOptimizationParameter>();
for (Element solverParam : listOfSolverParams) {
String paramName = solverParam.getAttributeValue(OptimizationParameterNameAttribute);
double paramValue = Double.parseDouble(solverParam.getAttributeValue(OptimizationParameterValueAttribute));
CopasiOptimizationParameter copasiParam = new CopasiOptimizationParameter(getCopasiOptimizationParameterTypeByName(paramName), paramValue);
copasiSolverParams.add(copasiParam);
}
copasiOptMethod = new CopasiOptimizationMethod(getCopasiOptimizationMethodTypeByName(optimizationSolverTypeName), copasiSolverParams.toArray(new CopasiOptimizationParameter[copasiSolverParams.size()]));
} else // no parameters
{
copasiOptMethod = new CopasiOptimizationMethod(getCopasiOptimizationMethodTypeByName(optimizationSolverTypeName), new CopasiOptimizationParameter[0]);
}
optSolverSpec = new OptimizationSolverSpec(copasiOptMethod);
// add number of runs attribute
String numOfRunsStr = optimizationSolverSpecElement.getAttributeValue(OptimizationSolverNumOfRunsAttribute);
if (numOfRunsStr != null) {
int numOfRuns = Integer.parseInt(numOfRunsStr);
optSolverSpec.setNumOfRuns(numOfRuns);
}
}
parameterEstimationTask.setOptimizationSolverSpec(optSolverSpec);
}
if (// optimization solver spec is null create a default copasi evolutionary programming
optimizationSolverSpecElement == null || parameterEstimationTask.getOptimizationSolverSpec() == null) {
OptimizationSolverSpec optSolverSpec = new OptimizationSolverSpec(new CopasiOptimizationMethod(CopasiOptimizationMethodType.EvolutionaryProgram));
parameterEstimationTask.setOptimizationSolverSpec(optSolverSpec);
}
// read optimization solver result set
Element optimizationResultSetElement = parameterEstimationTaskElement.getChild(OptXmlTags.OptimizationResultSet_Tag, ns);
if (optimizationResultSetElement != null) {
OptimizationResultSet optResultSet = null;
// read optsolverResultSet
if (optimizationResultSetElement.getChild(OptXmlTags.bestOptRunResultSet_Tag, ns) != null) {
Element optSolverResultSetElement = optimizationResultSetElement.getChild(OptXmlTags.bestOptRunResultSet_Tag, ns);
OptSolverResultSet optSolverResultSet = null;
// get best parameters, best func value, number of evaluations and construct an optRunResultSet
Element paramListElement = optSolverResultSetElement.getChild(OptimizationListOfParametersTag, ns);
OptRunResultSet optRunResultSet = null;
List<String> paramNames = new ArrayList<String>();
List<Double> paramValues = new ArrayList<Double>();
if (paramListElement != null && !paramListElement.getChildren().isEmpty()) {
List<Element> paramElements = paramListElement.getChildren(OptimizationParameterTag, ns);
if (paramElements != null) {
for (Element paramElement : paramElements) {
String paramName = paramElement.getAttributeValue(OptimizationParameterNameAttribute);
double paramValue = Double.parseDouble(paramElement.getAttributeValue(OptimizationParameterValueAttribute));
paramNames.add(paramName);
paramValues.add(paramValue);
}
}
}
Element bestFuncValueElement = optSolverResultSetElement.getChild(OptXmlTags.ObjectiveFunction_Tag, ns);
double bestFuncValue = Double.parseDouble(bestFuncValueElement.getAttributeValue(OptimizationParameterValueAttribute));
Element numEvaluationsElement = optSolverResultSetElement.getChild(OptXmlTags.OptSolverResultSetFunctionEvaluations_Tag, ns);
long numEvaluations = Long.parseLong(numEvaluationsElement.getAttributeValue(OptimizationParameterValueAttribute));
// change List<Double> to double[]
double[] values = new double[paramValues.size()];
int index = 0;
for (Double value : paramValues) {
values[index++] = value;
}
optRunResultSet = new OptRunResultSet(values, bestFuncValue, numEvaluations, null);
// create optSolverResultSet
optSolverResultSet = new OptSolverResultSet(paramNames.toArray(new String[paramNames.size()]), optRunResultSet);
// create optimization result set
optResultSet = new OptimizationResultSet(optSolverResultSet, null);
}
parameterEstimationTask.setOptimizationResultSet(optResultSet);
}
return parameterEstimationTask;
}
use of org.vcell.util.CommentStringTokenizer in project vcell by virtualcell.
the class BioCartoonTool method pasteReactionSteps0.
/**
* pasteReactionSteps0 : does the actual pasting. First called with a cloned model, to track issues. If user still wants to proceed, the paste
* is performed on the original model.
*
* Insert the method's description here.
* Creation date: (5/10/2003 3:55:25 PM)
* @param pasteToModel cbit.vcell.model.Model
* @param pasteToStructure cbit.vcell.model.Structure
* @param bNew boolean
*/
private static final PasteHelper pasteReactionSteps0(HashMap<String, HashMap<ReactionParticipant, Structure>> rxPartMapStructure, Component parent, IssueContext issueContext, ReactionStep[] copyFromRxSteps, Model pasteToModel, Structure pasteToStructure, boolean bNew, /*boolean bUseDBSpecies,*/
UserResolvedRxElements userResolvedRxElements) throws Exception {
HashMap<BioModelEntityObject, BioModelEntityObject> reactionsAndSpeciesContexts = new HashMap<>();
if (copyFromRxSteps == null || copyFromRxSteps.length == 0 || pasteToModel == null || pasteToStructure == null) {
throw new IllegalArgumentException("CartoonTool.pasteReactionSteps Error " + (copyFromRxSteps == null || copyFromRxSteps.length == 0 ? "reactionStepsArr empty " : "") + (pasteToModel == null ? "model is null " : "") + (pasteToStructure == null ? "struct is null " : ""));
}
if (!pasteToModel.contains(pasteToStructure)) {
throw new IllegalArgumentException("CartoonTool.pasteReactionSteps model " + pasteToModel.getName() + " does not contain structure " + pasteToStructure.getName());
}
// Check PasteToModel has preferred targets if set
if (userResolvedRxElements != null) {
for (int i = 0; i < userResolvedRxElements.toSpeciesArr.length; i++) {
if (userResolvedRxElements.toSpeciesArr[i] != null) {
if (!pasteToModel.contains(userResolvedRxElements.toSpeciesArr[i])) {
throw new RuntimeException("PasteToModel does not contain preferred Species " + userResolvedRxElements.toSpeciesArr[i]);
}
}
if (userResolvedRxElements.toStructureArr[i] != null) {
if (!pasteToModel.contains(userResolvedRxElements.toStructureArr[i])) {
throw new RuntimeException("PasteToModel does not contain preferred Structure " + userResolvedRxElements.toStructureArr[i]);
}
}
}
}
int counter = 0;
Structure currentStruct = pasteToStructure;
String copiedStructName = copyFromRxSteps[counter].getStructure().getName();
StructureTopology structTopology = (copyFromRxSteps[counter].getModel() == null ? pasteToModel.getStructureTopology() : copyFromRxSteps[counter].getModel().getStructureTopology());
IdentityHashMap<Species, Species> speciesHash = new IdentityHashMap<Species, Species>();
IdentityHashMap<SpeciesContext, SpeciesContext> speciesContextHash = new IdentityHashMap<SpeciesContext, SpeciesContext>();
Vector<Issue> issueVector = new Vector<Issue>();
do {
// create a new reaction, instead of cloning the old one; set struc
ReactionStep copyFromReactionStep = copyFromRxSteps[counter];
String newName = copyFromReactionStep.getName();
while (pasteToModel.getReactionStep(newName) != null) {
newName = org.vcell.util.TokenMangler.getNextEnumeratedToken(newName);
}
ReactionStep newReactionStep = null;
if (copyFromReactionStep instanceof SimpleReaction) {
newReactionStep = new SimpleReaction(pasteToModel, currentStruct, newName, copyFromReactionStep.isReversible());
} else if (copyFromReactionStep instanceof FluxReaction && currentStruct instanceof Membrane) {
newReactionStep = new FluxReaction(pasteToModel, (Membrane) currentStruct, null, newName, copyFromReactionStep.isReversible());
}
pasteToModel.addReactionStep(newReactionStep);
reactionsAndSpeciesContexts.put(newReactionStep, copyFromReactionStep);
Structure toRxnStruct = newReactionStep.getStructure();
Structure fromRxnStruct = copyFromReactionStep.getStructure();
if (!fromRxnStruct.getClass().equals(pasteToStructure.getClass())) {
throw new Exception("Cannot copy reaction from " + fromRxnStruct.getTypeName() + " to " + pasteToStructure.getTypeName() + ".");
}
// add appropriate reactionParticipants to newReactionStep.
StructureTopology toStructureTopology = pasteToModel.getStructureTopology();
ReactionParticipant[] copyFromRxParticipantArr = copyFromReactionStep.getReactionParticipants();
if (rxPartMapStructure == null) {
// null during 'issues' trial
rxPartMapStructure = new HashMap<String, HashMap<ReactionParticipant, Structure>>();
}
if (rxPartMapStructure.get(copyFromReactionStep.getName()) == null) {
// Ask user to assign species to compartments for each reaction to be pasted
rxPartMapStructure.put(copyFromReactionStep.getName(), askUserResolveMembraneConnections(parent, pasteToModel.getStructures(), currentStruct, fromRxnStruct, toRxnStruct, copyFromRxParticipantArr, toStructureTopology, structTopology));
}
for (int i = 0; i < copyFromRxParticipantArr.length; i += 1) {
Structure pasteToStruct = currentStruct;
// if(toRxnStruct instanceof Membrane){
pasteToStruct = rxPartMapStructure.get(copyFromReactionStep.getName()).get(copyFromRxParticipantArr[i]);
// if(pasteToStruct == null){
// for(ReactionParticipant myRXPart:rxPartMapStructure.get(copyFromReactionStep.getName()).keySet()){
// if(myRXPart.getSpeciesContext().getName().equals(copyFromRxParticipantArr[i].getSpeciesContext().getName())){
// pasteToStruct = rxPartMapStructure.get(copyFromReactionStep.getName()).get(myRXPart);
// break;
// }
// }
// }
// }
// this adds the speciesContexts and species (if any) to the model)
String rootSC = ReactionCartoonTool.speciesContextRootFinder(copyFromRxParticipantArr[i].getSpeciesContext());
SpeciesContext newSc = null;
SpeciesContext[] matchSC = pasteToModel.getSpeciesContexts();
for (int j = 0; matchSC != null && j < matchSC.length; j++) {
String matchRoot = ReactionCartoonTool.speciesContextRootFinder(matchSC[j]);
if (matchRoot != null && matchRoot.equals(rootSC) && matchSC[j].getStructure().getName().equals(pasteToStruct.getName())) {
newSc = matchSC[j];
reactionsAndSpeciesContexts.put(newSc, matchSC[j]);
break;
}
}
if (newSc == null) {
newSc = pasteSpecies(parent, copyFromRxParticipantArr[i].getSpecies(), rootSC, pasteToModel, pasteToStruct, bNew, /*bUseDBSpecies,*/
speciesHash, UserResolvedRxElements.getPreferredReactionElement(userResolvedRxElements, copyFromRxParticipantArr[i]));
reactionsAndSpeciesContexts.put(newSc, copyFromRxParticipantArr[i].getSpeciesContext());
}
// record the old-new speciesContexts (reactionparticipants) in the IdHashMap, this is useful, esp for 'Paste new', while replacing proxyparams.
SpeciesContext oldSc = copyFromRxParticipantArr[i].getSpeciesContext();
if (speciesContextHash.get(oldSc) == null) {
speciesContextHash.put(oldSc, newSc);
}
if (copyFromRxParticipantArr[i] instanceof Reactant) {
newReactionStep.addReactionParticipant(new Reactant(null, newReactionStep, newSc, copyFromRxParticipantArr[i].getStoichiometry()));
} else if (copyFromRxParticipantArr[i] instanceof Product) {
newReactionStep.addReactionParticipant(new Product(null, newReactionStep, newSc, copyFromRxParticipantArr[i].getStoichiometry()));
} else if (copyFromRxParticipantArr[i] instanceof Catalyst) {
newReactionStep.addCatalyst(newSc);
}
}
// // If 'newReactionStep' is a fluxRxn, set its fluxCarrier
// if (newReactionStep instanceof FluxReaction) {
// if (fluxCarrierSp != null) {
// ((FluxReaction)newReactionStep).setFluxCarrier(fluxCarrierSp, pasteToModel);
// } else {
// throw new RuntimeException("Could not set FluxCarrier species for the flux reaction to be pasted");
// }
// }
// For each kinetic parameter expression for new kinetics, replace the proxyParams from old kinetics with proxyParams in new kinetics
// i.e., if the proxyParams are speciesContexts, replace with corresponding speciesContext in newReactionStep;
// if the proxyParams are structureSizes or MembraneVoltages, replace with corresponding structure quantity in newReactionStep
Kinetics oldKinetics = copyFromReactionStep.getKinetics();
KineticsParameter[] oldKps = oldKinetics.getKineticsParameters();
KineticsProxyParameter[] oldKprps = oldKinetics.getProxyParameters();
Hashtable<String, Expression> paramExprHash = new Hashtable<String, Expression>();
for (int i = 0; oldKps != null && i < oldKps.length; i++) {
Expression newExpression = new Expression(oldKps[i].getExpression());
for (int j = 0; oldKprps != null && j < oldKprps.length; j++) {
// check if kinetic proxy parameter is in kinetic parameter expression
if (newExpression.hasSymbol(oldKprps[j].getName())) {
SymbolTableEntry ste = oldKprps[j].getTarget();
Model pasteFromModel = copyFromReactionStep.getModel();
if (ste instanceof SpeciesContext) {
// if newRxnStruct is a feature/membrane, get matching spContexts from old reaction and replace them in new rate expr.
SpeciesContext oldSC = (SpeciesContext) ste;
SpeciesContext newSC = speciesContextHash.get(oldSC);
if (newSC == null) {
// check if oldSc is present in paste-model; if not, add it.
if (!pasteToModel.equals(pasteFromModel)) {
if (pasteToModel.getSpeciesContext(oldSC.getName()) == null) {
// if paste-model has oldSc struct, paste it there,
Structure newSCStruct = pasteToModel.getStructure(oldSC.getStructure().getName());
if (newSCStruct != null) {
newSC = pasteSpecies(parent, oldSC.getSpecies(), null, pasteToModel, newSCStruct, bNew, /*bUseDBSpecies,*/
speciesHash, UserResolvedRxElements.getPreferredReactionElement(userResolvedRxElements, oldSC));
speciesContextHash.put(oldSC, newSC);
} else {
// oldStruct wasn't found in paste-model, paste it in newRxnStruct and add warning to issues list
newSC = pasteSpecies(parent, oldSC.getSpecies(), null, pasteToModel, toRxnStruct, bNew, /*bUseDBSpecies,*/
speciesHash, UserResolvedRxElements.getPreferredReactionElement(userResolvedRxElements, oldSC));
speciesContextHash.put(oldSC, newSC);
Issue issue = new Issue(oldSC, issueContext, IssueCategory.CopyPaste, "SpeciesContext '" + oldSC.getSpecies().getCommonName() + "' was not found in compartment '" + oldSC.getStructure().getName() + "' in the model; the species was added to the compartment '" + toRxnStruct.getName() + "' where the reaction was pasted.", Issue.SEVERITY_WARNING);
issueVector.add(issue);
}
}
}
// if models are the same and newSc is null, then oldSc is not a rxnParticipant. Leave it as is in the expr.
}
if (newSC != null) {
reactionsAndSpeciesContexts.put(newSC, oldSC);
newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(newSC.getName()));
}
// SpeciesContext sc = null;
// Species newSp = model.getSpecies(oldSc.getSpecies().getCommonName());
// if (oldSc.getStructure() == (oldRxnStruct)) {
// sc = model.getSpeciesContext(newSp, newRxnStruct);
// } else {
// if (newRxnStruct instanceof Membrane) {
// // for a membrane, we need to make sure that inside-outside spContexts used are appropriately replaced.
// if (oldSc.getStructure() == ((Membrane)oldRxnStruct).getOutsideFeature()) {
// // old speciesContext is outside (old) membrane, new spContext should be outside new membrane
// sc = model.getSpeciesContext(newSp, ((Membrane)newRxnStruct).getOutsideFeature());
// } else if (oldSc.getStructure() == ((Membrane)oldRxnStruct).getInsideFeature()) {
// // old speciesContext is inside (old) membrane, new spContext should be inside new membrane
// sc = model.getSpeciesContext(newSp, ((Membrane)newRxnStruct).getInsideFeature());
// }
// }
// }
// if (sc != null) {
// newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(sc.getName()));
// }
} else if (ste instanceof StructureSize) {
Structure str = ((StructureSize) ste).getStructure();
// if the structure size used is same as the structure in which the reaction is present, change the structSize to appropriate new struct
if (str.compareEqual(fromRxnStruct)) {
newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(toRxnStruct.getStructureSize().getName()));
} else {
if (fromRxnStruct instanceof Membrane) {
if (str.equals(structTopology.getOutsideFeature((Membrane) fromRxnStruct))) {
newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(structTopology.getOutsideFeature((Membrane) toRxnStruct).getStructureSize().getName()));
} else if (str.equals(structTopology.getInsideFeature((Membrane) fromRxnStruct))) {
newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(structTopology.getInsideFeature((Membrane) toRxnStruct).getStructureSize().getName()));
}
}
}
} else if (ste instanceof MembraneVoltage) {
Membrane membr = ((MembraneVoltage) ste).getMembrane();
// if the MembraneVoltage used is same as that of the membrane in which the reaction is present, change the MemVoltage
if ((fromRxnStruct instanceof Membrane) && (membr.compareEqual(fromRxnStruct))) {
newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(((Membrane) toRxnStruct).getMembraneVoltage().getName()));
}
} else if (ste instanceof ModelParameter) {
// see if model has this global parameter (if rxn is being pasted into another model, it won't)
if (!pasteToModel.equals(pasteFromModel)) {
ModelParameter oldMp = (ModelParameter) ste;
ModelParameter mp = pasteToModel.getModelParameter(oldMp.getName());
boolean bNonNumeric = false;
String newMpName = oldMp.getName();
if (mp != null) {
// new model has a model parameter with same name - are they the same param?
if (!mp.getExpression().equals(oldMp.getExpression())) {
// no, they are not the same param, so mangle the 'ste' name and add as global in the other model
while (pasteToModel.getModelParameter(newMpName) != null) {
newMpName = TokenMangler.getNextEnumeratedToken(newMpName);
}
// if expression if numeric, add it as such. If not, set it to 0.0 and add it as global
Expression exp = oldMp.getExpression();
if (!exp.flatten().isNumeric()) {
exp = new Expression(0.0);
bNonNumeric = true;
}
ModelParameter newMp = pasteToModel.new ModelParameter(newMpName, exp, Model.ROLE_UserDefined, oldMp.getUnitDefinition());
String annotation = "Copied from model : " + pasteFromModel.getNameScope();
newMp.setModelParameterAnnotation(annotation);
pasteToModel.addModelParameter(newMp);
// if global param name had to be changed, make sure newExpr is updated as well.
if (!newMpName.equals(oldMp.getName())) {
newExpression.substituteInPlace(new Expression(oldMp.getName()), new Expression(newMpName));
}
}
} else {
// no global param with same name was found in other model, so add it to other model.
// if expression if numeric, add it as such. If not, set it to 0.0 and add it as global
Expression exp = oldMp.getExpression();
if (!exp.flatten().isNumeric()) {
exp = new Expression(0.0);
bNonNumeric = true;
}
ModelParameter newMp = pasteToModel.new ModelParameter(newMpName, exp, Model.ROLE_UserDefined, oldMp.getUnitDefinition());
String annotation = "Copied from model : " + pasteFromModel.getNameScope();
newMp.setModelParameterAnnotation(annotation);
pasteToModel.addModelParameter(newMp);
}
// if a non-numeric parameter was encountered in the old model, it was added as a numeric (0.0), warn user of change.
if (bNonNumeric) {
Issue issue = new Issue(oldMp, issueContext, IssueCategory.CopyPaste, "Global parameter '" + oldMp.getName() + "' was non-numeric; it has been added " + "as global parameter '" + newMpName + "' in the new model with value = 0.0. " + "Please update its value, if required, before using it.", Issue.SEVERITY_WARNING);
issueVector.add(issue);
}
}
}
}
// end - if newExpr.hasSymbol(ProxyParam)
}
// now if store <param names, new expression> in hashTable
if (paramExprHash.get(oldKps[i].getName()) == null) {
paramExprHash.put(oldKps[i].getName(), newExpression);
}
}
// end for - oldKps (old kinetic parameters)
// use this new expression to generate 'vcml' for the (new) kinetics (easier way to transfer all kinetic parameters)
String newKineticsStr = oldKinetics.writeTokensWithReplacingProxyParams(paramExprHash);
// convert the kinetics 'vcml' to tokens.
CommentStringTokenizer kineticsTokens = new CommentStringTokenizer(newKineticsStr);
// skip the first token;
kineticsTokens.nextToken();
// second token is the kinetic type; use this to create a dummy kinetics
String kineticType = kineticsTokens.nextToken();
Kinetics newkinetics = KineticsDescription.fromVCMLKineticsName(kineticType).createKinetics(newReactionStep);
// use the remaining tokens to construct the new kinetics
newkinetics.fromTokens(newKineticsStr);
// bind newkinetics to newReactionStep and add it to newReactionStep
newkinetics.bind(newReactionStep);
newReactionStep.setKinetics(newkinetics);
counter += 1;
if (counter == copyFromRxSteps.length) {
break;
}
if (!copiedStructName.equals(fromRxnStruct.getName())) {
if (currentStruct instanceof Feature) {
currentStruct = structTopology.getMembrane((Feature) currentStruct);
} else if (currentStruct instanceof Membrane) {
currentStruct = structTopology.getInsideFeature((Membrane) currentStruct);
}
}
copiedStructName = fromRxnStruct.getName();
} while (true);
return new PasteHelper(issueVector, rxPartMapStructure, reactionsAndSpeciesContexts);
}
use of org.vcell.util.CommentStringTokenizer in project vcell by virtualcell.
the class SimulationTable method getSimulationRep.
public SimulationRep getSimulationRep(ResultSet rset, DatabaseSyntax dbSyntax) throws IllegalArgumentException, SQLException, DataAccessException {
KeyValue scKey = new KeyValue(rset.getBigDecimal(table.id.toString()));
String name = rset.getString(table.name.toString());
BigDecimal branchID = rset.getBigDecimal(table.versionBranchID.toString());
KeyValue ownerRef = new KeyValue(rset.getBigDecimal(table.ownerRef.toString()));
String ownerName = rset.getString(UserTable.table.userid.toString());
User owner = new User(ownerName, ownerRef);
KeyValue mathKey = new KeyValue(rset.getBigDecimal(table.mathRef.toString()));
String taskDesc = rset.getString(table.taskDescription.toString());
SolverTaskDescription solverTaskDescription = null;
try {
solverTaskDescription = new SolverTaskDescription(new CommentStringTokenizer(taskDesc));
} catch (DataAccessException e) {
System.out.println("SimulationTable:getSimulationRep(): failed to parse solver task description, exception=[" + e.getMessage() + "]::\n[[[" + taskDesc + "]]]\n");
// e.printStackTrace();
}
CommentStringTokenizer mathOverridesTokenizer = getMathOverridesTokenizer(rset, dbSyntax);
List<Element> mathOverrideElements = MathOverrides.parseOverrideElementsFromVCML(mathOverridesTokenizer);
return new SimulationRep(scKey, branchID, name, owner, mathKey, solverTaskDescription, mathOverrideElements.toArray(new MathOverrides.Element[0]));
}
Aggregations