use of cbit.vcell.math.OutsideVariable in project vcell by virtualcell.
the class XmlReader method getOutsideVariable.
/**
* This method returns an OutsideVariable object from a XML Element
* Creation date: (5/18/2001 6:14:42 PM)
* @return cbit.vcell.math.InsideVariable
* @param param org.jdom.Element
*/
private OutsideVariable getOutsideVariable(Element param) {
// Get name
String name = unMangle(param.getAttributeValue(XMLTags.NameAttrTag));
// get VolVariableRef
String volvarName = unMangle(param.getAttributeValue(XMLTags.VolumeVariableAttrTag));
// *** create new OutsideVariable ***
OutsideVariable variable = new OutsideVariable(name, volvarName);
transcribeComments(param, variable);
return variable;
}
use of cbit.vcell.math.OutsideVariable 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.OutsideVariable in project vcell by virtualcell.
the class SimulationSymbolTable method createAnnotatedFunctionsList.
public Vector<AnnotatedFunction> createAnnotatedFunctionsList(MathDescription mathDescription) throws InconsistentDomainException {
// Get the list of (volVariables) in the simulation. Needed to determine 'type' of functions
boolean bSpatial = getSimulation().isSpatial();
String[] variableNames = null;
VariableType[] variableTypes = null;
if (bSpatial) {
Variable[] allVariables = getVariables();
Vector<Variable> varVector = new Vector<Variable>();
for (int i = 0; i < allVariables.length; i++) {
if ((allVariables[i] instanceof VolVariable) || (allVariables[i] instanceof VolumeRegionVariable) || (allVariables[i] instanceof MemVariable) || (allVariables[i] instanceof MembraneRegionVariable) || (allVariables[i] instanceof FilamentVariable) || (allVariables[i] instanceof FilamentRegionVariable) || (allVariables[i] instanceof PointVariable) || (allVariables[i] instanceof ParticleVariable) || (allVariables[i] instanceof InsideVariable) || (allVariables[i] instanceof OutsideVariable)) {
varVector.addElement(allVariables[i]);
} else if (allVariables[i] instanceof Constant || (allVariables[i] instanceof Function)) {
} else {
System.err.println("SimulationSymbolTable.createAnnotatedFunctionsList() found unexpected variable type " + allVariables[i].getClass().getSimpleName() + " in spatial simulation");
}
}
variableNames = new String[varVector.size()];
for (int i = 0; i < variableNames.length; i++) {
variableNames[i] = varVector.get(i).getName();
}
// Lookup table for variableType for each variable in 'variables' array.
variableTypes = new VariableType[variableNames.length];
for (int i = 0; i < variableNames.length; i++) {
variableTypes[i] = VariableType.getVariableType(varVector.get(i));
}
}
//
// Bind and substitute functions to simulation before storing them in the '.functions' file
//
Function[] functions = getFunctions();
Vector<AnnotatedFunction> annotatedFunctionVector = new Vector<AnnotatedFunction>();
for (int i = 0; i < functions.length; i++) {
if (isFunctionSaved(functions[i])) {
String errString = "";
VariableType funcType = null;
try {
Expression substitutedExp = substituteFunctions(functions[i].getExpression());
substitutedExp.bindExpression(this);
functions[i].setExpression(substitutedExp.flatten());
} catch (MathException e) {
e.printStackTrace(System.out);
errString = errString + ", " + e.getMessage();
// throw new RuntimeException(e.getMessage());
} catch (ExpressionException e) {
e.printStackTrace(System.out);
errString = errString + ", " + e.getMessage();
// throw new RuntimeException(e.getMessage());
}
//
// get function's data type from the types of it's identifiers
//
funcType = bSpatial ? getFunctionVariableType(functions[i], mathDescription, variableNames, variableTypes, bSpatial) : VariableType.NONSPATIAL;
AnnotatedFunction annotatedFunc = new AnnotatedFunction(functions[i].getName(), functions[i].getExpression(), functions[i].getDomain(), errString, funcType, FunctionCategory.PREDEFINED);
annotatedFunctionVector.addElement(annotatedFunc);
}
}
return annotatedFunctionVector;
}
use of cbit.vcell.math.OutsideVariable in project vcell by virtualcell.
the class SimulationData method getVarAndFunctionDataIdentifiers.
/**
* This method was created in VisualAge.
* @return java.lang.String[]
*/
public synchronized DataIdentifier[] getVarAndFunctionDataIdentifiers(OutputContext outputContext) throws IOException, DataAccessException {
// Is this zip format?
boolean bIsChombo = false;
try {
bIsChombo = isChombo();
} catch (FileNotFoundException e) {
e.printStackTrace(System.out);
}
File zipFile1 = getZipFile(bIsChombo, null);
File zipFile2 = getZipFile(bIsChombo, 0);
bZipFormat1 = false;
bZipFormat2 = false;
if (zipFile1.exists()) {
bZipFormat1 = true;
} else if (zipFile2.exists()) {
bZipFormat2 = true;
}
refreshLogFile();
if (!isComsol()) {
try {
refreshMeshFile();
} catch (MathException e) {
e.printStackTrace(System.out);
throw new DataAccessException(e.getMessage());
}
}
if (!isRulesData && !getIsODEData() && !isComsol() && dataFilenames != null) {
// read variables only when I have never read the file since variables don't change
if (dataSetIdentifierList.size() == 0) {
File file = getPDEDataFile(0.0);
DataSet dataSet = getPDEDataSet(file, 0.0);
String[] varNames = dataSet.getDataNames();
int[] varTypeInts = dataSet.getVariableTypeIntegers();
if (varNames == null) {
return null;
}
dataSetIdentifierList.clear();
for (int i = 0; i < varNames.length; i++) {
VariableType varType = null;
try {
varType = VariableType.getVariableTypeFromInteger(varTypeInts[i]);
} catch (IllegalArgumentException e) {
if (LG.isEnabledFor(Level.WARN)) {
LG.warn("Exception typing " + varNames[i] + " has unsupported type " + varTypeInts[i] + ": " + e.getMessage());
}
varType = SimulationData.getVariableTypeFromLength(mesh, dataSet.getDataLength(varNames[i]));
}
Domain domain = Variable.getDomainFromCombinedIdentifier(varNames[i]);
String varName = Variable.getNameFromCombinedIdentifier(varNames[i]);
dataSetIdentifierList.addElement(new DataSetIdentifier(varName, varType, domain));
}
refreshDataProcessingOutputInfo(outputContext);
if (dataProcessingOutputInfo != null) {
for (int i = 0; i < dataProcessingOutputInfo.getVariableNames().length; i++) {
if (dataProcessingOutputInfo.getPostProcessDataType(dataProcessingOutputInfo.getVariableNames()[i]).equals(DataProcessingOutputInfo.PostProcessDataType.image)) {
dataSetIdentifierList.addElement(new DataSetIdentifier(dataProcessingOutputInfo.getVariableNames()[i], VariableType.POSTPROCESSING, null));
}
}
}
}
// always read functions file since functions might change
getFunctionDataIdentifiers(outputContext);
}
if ((isRulesData || getIsODEData()) && dataSetIdentifierList.size() == 0) {
ODEDataBlock odeDataBlock = getODEDataBlock();
if (odeDataBlock == null) {
throw new DataAccessException("Results are not availabe yet. Please try again later.");
}
ODESimData odeSimData = odeDataBlock.getODESimData();
int colCount = odeSimData.getColumnDescriptionsCount();
// assume index=0 is time "t"
int DATA_OFFSET = 1;
dataSetIdentifierList.clear();
for (int i = 0; i < (colCount - DATA_OFFSET); i++) {
String varName = odeSimData.getColumnDescriptions(i + DATA_OFFSET).getDisplayName();
// TODO domain
Domain domain = null;
dataSetIdentifierList.addElement(new DataSetIdentifier(varName, VariableType.NONSPATIAL, domain));
}
}
if (isComsol() && dataSetIdentifierList.size() == 0) {
ComsolSimFiles comsolSimFiles = getComsolSimFiles();
if (comsolSimFiles.simTaskXMLFile != null) {
try {
String xmlString = FileUtils.readFileToString(comsolSimFiles.simTaskXMLFile);
SimulationTask simTask = XmlHelper.XMLToSimTask(xmlString);
Enumeration<Variable> variablesEnum = simTask.getSimulation().getMathDescription().getVariables();
while (variablesEnum.hasMoreElements()) {
Variable var = variablesEnum.nextElement();
if (var instanceof VolVariable) {
dataSetIdentifierList.addElement(new DataSetIdentifier(var.getName(), VariableType.VOLUME, var.getDomain()));
} else if (var instanceof MemVariable) {
dataSetIdentifierList.addElement(new DataSetIdentifier(var.getName(), VariableType.MEMBRANE, var.getDomain()));
} else if (var instanceof Function) {
VariableType varType = VariableType.UNKNOWN;
if (var.getDomain() != null && var.getDomain().getName() != null) {
SubDomain subDomain = simTask.getSimulation().getMathDescription().getSubDomain(var.getDomain().getName());
if (subDomain instanceof CompartmentSubDomain) {
varType = VariableType.VOLUME;
} else if (subDomain instanceof MembraneSubDomain) {
varType = VariableType.MEMBRANE;
} else if (subDomain instanceof FilamentSubDomain) {
throw new RuntimeException("filament subdomains not supported");
} else if (subDomain instanceof PointSubDomain) {
varType = VariableType.POINT_VARIABLE;
}
}
dataSetIdentifierList.addElement(new DataSetIdentifier(var.getName(), varType, var.getDomain()));
} else if (var instanceof Constant) {
System.out.println("ignoring Constant " + var.getName());
} else if (var instanceof InsideVariable) {
System.out.println("ignoring InsideVariable " + var.getName());
} else if (var instanceof OutsideVariable) {
System.out.println("ignoring OutsideVariable " + var.getName());
} else {
throw new RuntimeException("unexpected variable " + var.getName() + " of type " + var.getClass().getName());
}
}
} catch (XmlParseException | ExpressionException e) {
e.printStackTrace();
throw new RuntimeException("failed to read sim task file, msg: " + e.getMessage(), e);
}
}
}
DataIdentifier[] dis = new DataIdentifier[dataSetIdentifierList.size()];
for (int i = 0; i < dataSetIdentifierList.size(); i++) {
DataSetIdentifier dsi = (DataSetIdentifier) dataSetIdentifierList.elementAt(i);
String displayName = dsi.getName();
if (dsi.isFunction()) {
AnnotatedFunction f = null;
for (int j = 0; j < annotatedFunctionList.size(); j++) {
AnnotatedFunction function = (AnnotatedFunction) annotatedFunctionList.elementAt(j);
if (function.getName().equals(dsi.getName())) {
f = function;
break;
}
}
if (f != null) {
displayName = f.getDisplayName();
}
}
dis[i] = new DataIdentifier(dsi.getName(), dsi.getVariableType(), dsi.getDomain(), dsi.isFunction(), displayName);
}
return dis;
}
use of cbit.vcell.math.OutsideVariable in project vcell by virtualcell.
the class OutputFunctionContext method getAutoCompleteSymbolFilter.
public AutoCompleteSymbolFilter getAutoCompleteSymbolFilter() {
AutoCompleteSymbolFilter stef = new AutoCompleteSymbolFilter() {
public boolean accept(SymbolTableEntry ste) {
MathDescription math = getSimulationOwner().getMathDescription();
Variable var = math.getVariable(ste.getName());
return (!(var instanceof InsideVariable || var instanceof OutsideVariable));
}
public boolean acceptFunction(String funcName) {
return true;
}
};
return stef;
}
Aggregations