Example 56 with Version
use of org.vcell.util.document.Version in project vcell by virtualcell.
the class ServerDocumentManager method saveSimulation.
/**
* Insert the method's description here.
* Creation date: (10/28/00 12:08:30 AM)
* @deprecated for testing purposes only.
*/
public String saveSimulation(QueryHashtable dbc, User user, String simulationXML, boolean bForceIndependent) throws DataAccessException, java.sql.SQLException, java.beans.PropertyVetoException, cbit.vcell.xml.XmlParseException {
//
// this invokes "update" on the database layer
//
Simulation simulation = XmlHelper.XMLToSim(simulationXML);
forceDeepDirtyIfForeign(user, simulation);
Version oldVersion = simulation.getVersion();
Simulation origSimulation = null;
if (oldVersion != null) {
try {
origSimulation = dbServer.getDBTopLevel().getSimulation(dbc, user, oldVersion.getVersionKey());
} catch (ObjectNotFoundException e) {
}
}
boolean bSomethingChanged = false;
//
// UPDATE AND SUBSTITUTE FROM BOTTOM UP
//
// Image->Geometry
// Geometry->MathDescription
// MathDescription->Simulation
//
//
// if this simulation has an image:
// save if necessary (only once) and store saved instance in hashTable
//
Hashtable<Versionable, Versionable> memoryToDatabaseHash = new Hashtable<Versionable, Versionable>();
{
VCImage memoryImage = simulation.getMathDescription().getGeometry().getGeometrySpec().getImage();
if (memoryImage != null) {
// defaults to unchanged
memoryToDatabaseHash.put(memoryImage, memoryImage);
if (memoryImage.getKey() != null && memoryImage.getVersion().getName().equals(memoryImage.getName())) {
//
// if image had previously been saved, not been forced 'dirty', and name not changed
// compare with original image to see if "update" is required.
//
VCImage databaseImage = null;
if (origSimulation != null) {
VCImage origImage = origSimulation.getMathDescription().getGeometry().getGeometrySpec().getImage();
if (origImage != null && origImage.getKey().equals(memoryImage.getKey())) {
databaseImage = origImage;
}
}
if (databaseImage == null) {
//
// saved image not found in origMathModel (too bad), get from database.
//
databaseImage = dbServer.getDBTopLevel().getVCImage(dbc, user, memoryImage.getKey(), false);
}
if (databaseImage != null && !databaseImage.compareEqual(memoryImage)) {
KeyValue updatedImageKey = dbServer.getDBTopLevel().updateVersionable(user, memoryImage, false, true);
VCImage updatedImage = dbServer.getDBTopLevel().getVCImage(dbc, user, updatedImageKey, false);
memoryToDatabaseHash.put(memoryImage, updatedImage);
bSomethingChanged = true;
}
} else {
//
// Image hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a unique name
//
int count = 0;
fixNullImageName(memoryImage);
while (dbServer.getDBTopLevel().isNameUsed(user, VersionableType.VCImage, memoryImage.getName(), true)) {
try {
memoryImage.setName(TokenMangler.getNextRandomToken(memoryImage.getName()));
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
if (count++ > 5) {
throw new DataAccessException("failed to find unique image name '" + memoryImage.getName() + "' is last name tried");
}
}
KeyValue updatedImageKey = dbServer.getDBTopLevel().insertVersionable(user, memoryImage, memoryImage.getName(), false, true);
VCImage updatedImage = dbServer.getDBTopLevel().getVCImage(dbc, user, updatedImageKey, false);
memoryToDatabaseHash.put(memoryImage, updatedImage);
bSomethingChanged = true;
}
}
}
//
// for the Geometry:
// substitute saved Image into Geometry and
// save Geometry if necessary (only once) and store saved instance in hashtable.
//
{
Geometry memoryGeometry = simulation.getMathDescription().getGeometry();
// defaults to unchanged
memoryToDatabaseHash.put(memoryGeometry, memoryGeometry);
boolean bMustSaveGeometry = false;
VCImage geometryImage = memoryGeometry.getGeometrySpec().getImage();
if (geometryImage != null && memoryToDatabaseHash.get(geometryImage) != geometryImage) {
//
// image had changed and was saved, load saved image into geometry and force a save of this geometry.
//
memoryGeometry.getGeometrySpec().setImage((VCImage) memoryToDatabaseHash.get(geometryImage));
geometryImage = (VCImage) memoryToDatabaseHash.get(geometryImage);
bMustSaveGeometry = true;
}
if (memoryGeometry.getKey() != null && memoryGeometry.getVersion().getName().equals(memoryGeometry.getName())) {
if (!bMustSaveGeometry) {
//
// if geometry had previously been saved, not been forced 'dirty', and name not changed
// compare with original geometry to see if "update" is required.
//
Geometry databaseGeometry = null;
if (origSimulation != null) {
Geometry origGeometry = origSimulation.getMathDescription().getGeometry();
if (origGeometry.getKey().equals(memoryGeometry.getKey())) {
databaseGeometry = origGeometry;
}
}
if (databaseGeometry == null) {
//
// saved geometry not found in origMathModel (too bad), get from database.
//
databaseGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, memoryGeometry.getKey(), false);
}
if (databaseGeometry != null && !databaseGeometry.compareEqual(memoryGeometry)) {
bMustSaveGeometry = true;
}
}
if (bMustSaveGeometry) {
KeyValue updatedImageKey = (geometryImage != null) ? (geometryImage.getKey()) : (null);
KeyValue updatedGeometryKey = dbServer.getDBTopLevel().updateVersionable(dbc, user, memoryGeometry, updatedImageKey, false, true);
Geometry updatedGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, updatedGeometryKey, false);
memoryToDatabaseHash.put(memoryGeometry, updatedGeometry);
bSomethingChanged = true;
}
} else {
//
// Geometry hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a unique name
//
int count = 0;
while (dbServer.getDBTopLevel().isNameUsed(user, VersionableType.Geometry, memoryGeometry.getName(), true)) {
try {
memoryGeometry.setName(TokenMangler.getNextRandomToken(memoryGeometry.getName()));
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
if (count++ > 5) {
throw new DataAccessException("failed to find unique geometry name '" + memoryGeometry.getName() + "' is last name tried");
}
}
KeyValue updatedImageKey = (geometryImage != null) ? (geometryImage.getKey()) : (null);
KeyValue updatedGeometryKey = dbServer.getDBTopLevel().insertVersionable(dbc, user, memoryGeometry, updatedImageKey, memoryGeometry.getName(), false, true);
Geometry updatedGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, updatedGeometryKey, false);
memoryToDatabaseHash.put(memoryGeometry, updatedGeometry);
bSomethingChanged = true;
}
}
//
// for the MathDescription:
// substitute saved geometry into MathDescription
// save MathDescription if necessary (only once) and store saved instance in hashtable.
//
MathCompareResults mathCompareResults = null;
{
MathDescription memoryMathDescription = simulation.getMathDescription();
// defaults to unchanged
memoryToDatabaseHash.put(memoryMathDescription, memoryMathDescription);
boolean bMustSaveMathDescription = false;
Geometry scGeometry = memoryMathDescription.getGeometry();
if (scGeometry != null && memoryToDatabaseHash.get(scGeometry) != scGeometry) {
//
// geometry had changed and was saved, load saved geometry into SimulationContext (and it's MathDescription) and force a save of this SimulationContext.
//
memoryMathDescription.setGeometry((Geometry) memoryToDatabaseHash.get(scGeometry));
bMustSaveMathDescription = true;
}
if (memoryMathDescription.getKey() != null && memoryMathDescription.getVersion().getName().equals(memoryMathDescription.getName())) {
if (!bMustSaveMathDescription) {
//
// if MathDescription had previously been saved, not been forced 'dirty', and name not changed
// compare with original MathDescription to see if "update" is required.
//
MathDescription databaseMathDescription = null;
if (origSimulation != null) {
MathDescription origMathDescription = origSimulation.getMathDescription();
if (origMathDescription.getKey().equals(memoryMathDescription.getKey())) {
databaseMathDescription = origMathDescription;
}
}
if (databaseMathDescription == null) {
//
// saved mathDescription not found in origMathModel (too bad), get from database.
//
databaseMathDescription = dbServer.getDBTopLevel().getMathDescription(dbc, user, memoryMathDescription.getKey());
}
if (databaseMathDescription != null) {
mathCompareResults = MathDescription.testEquivalency(SimulationSymbolTable.createMathSymbolTableFactory(), memoryMathDescription, databaseMathDescription);
if (!mathCompareResults.decision.equals(Decision.MathEquivalent_SAME_MATHDESC_AS_IN_DB)) {
bMustSaveMathDescription = true;
}
}
}
if (bMustSaveMathDescription) {
KeyValue updatedGeometryKey = memoryMathDescription.getGeometry().getKey();
KeyValue updatedMathDescriptionKey = dbServer.getDBTopLevel().updateVersionable(user, memoryMathDescription, updatedGeometryKey, false, true);
MathDescription updatedMathDescription = dbServer.getDBTopLevel().getMathDescription(dbc, user, updatedMathDescriptionKey);
memoryToDatabaseHash.put(memoryMathDescription, updatedMathDescription);
bSomethingChanged = true;
}
} else {
//
// MathDescription hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a any name (doens't have to be unique ... mathDescription is not a top-level versionable).
//
KeyValue updatedGeometryKey = memoryMathDescription.getGeometry().getKey();
KeyValue updatedMathDescriptionKey = dbServer.getDBTopLevel().insertVersionable(user, memoryMathDescription, updatedGeometryKey, memoryMathDescription.getName(), false, true);
MathDescription updatedMathDescription = dbServer.getDBTopLevel().getMathDescription(dbc, user, updatedMathDescriptionKey);
memoryToDatabaseHash.put(memoryMathDescription, updatedMathDescription);
bSomethingChanged = true;
}
}
//
// for each Simulation in document:
// substitute saved MathDescriptions into Simulation and
// save Simulation if necessary (only once) and store saved instance in hashtable.
//
Simulation memorySimulation = simulation;
//
// didn't evaluate this Simulation yet.
//
// defaults to unchanged
memoryToDatabaseHash.put(memorySimulation, memorySimulation);
boolean bMustSaveSimulation = false;
MathDescription simMathDescription = memorySimulation.getMathDescription();
if (simMathDescription != null && memoryToDatabaseHash.get(simMathDescription) != simMathDescription) {
if (memoryToDatabaseHash.get(simMathDescription) != null) {
// make sure mathDescription hasn't already propagated (newer math won't be in hashtable)
//
// mathDescription had changed and was saved, load saved mathDescription into SimulationContext (and force a save)
//
memorySimulation.setMathDescription((MathDescription) memoryToDatabaseHash.get(simMathDescription));
bMustSaveSimulation = true;
}
}
Simulation databaseSimulation = null;
//
if (memorySimulation.getKey() != null) {
databaseSimulation = origSimulation;
if (databaseSimulation != null && !databaseSimulation.compareEqual(memorySimulation)) {
bMustSaveSimulation = true;
}
if (!memorySimulation.getVersion().getName().equals(memorySimulation.getName())) {
// name was changed.
bMustSaveSimulation = true;
}
} else {
// never been saved.
bMustSaveSimulation = true;
}
if (bMustSaveSimulation) {
KeyValue updatedMathDescriptionKey = memorySimulation.getMathDescription().getKey();
KeyValue updatedSimulationKey = null;
boolean bMathEquivalent = false;
if (origSimulation != null) {
bMathEquivalent = !bForceIndependent && Simulation.testEquivalency(memorySimulation, origSimulation, mathCompareResults);
}
if (memorySimulation.getKey() != null && memorySimulation.getVersion().getName().equals(memorySimulation.getName())) {
// name not changed, update simulation (but pass in database Simulation to check for parent-equivalence)
updatedSimulationKey = dbServer.getDBTopLevel().updateVersionable(user, memorySimulation, updatedMathDescriptionKey, false, bMathEquivalent, true);
} else {
// name changed, insert simulation (but pass in database Simulation to check for parent-equivalence)
updatedSimulationKey = dbServer.getDBTopLevel().insertVersionable(user, memorySimulation, updatedMathDescriptionKey, memorySimulation.getName(), false, bMathEquivalent, true);
}
Simulation updatedSimulation = dbServer.getDBTopLevel().getSimulation(dbc, user, updatedSimulationKey);
memoryToDatabaseHash.put(memorySimulation, updatedSimulation);
bSomethingChanged = true;
simulationXML = XmlHelper.simToXML(updatedSimulation);
return simulationXML;
} else {
return simulationXML;
}
}
Also used :
KeyValue(org.vcell.util.document.KeyValue)
MathDescription(cbit.vcell.math.MathDescription)
Hashtable(java.util.Hashtable)
QueryHashtable(cbit.sql.QueryHashtable)
VCImage(cbit.image.VCImage)
Versionable(org.vcell.util.document.Versionable)
PropertyVetoException(java.beans.PropertyVetoException)
Geometry(cbit.vcell.geometry.Geometry)
Simulation(cbit.vcell.solver.Simulation)
Version(org.vcell.util.document.Version)
ObjectNotFoundException(org.vcell.util.ObjectNotFoundException)
MathCompareResults(cbit.vcell.math.MathCompareResults)
DataAccessException(org.vcell.util.DataAccessException)
Example 57 with Version
use of org.vcell.util.document.Version in project vcell by virtualcell.
the class ServerDocumentManager method saveMathModel.
/**
* Insert the method's description here.
* Creation date: (10/28/00 12:08:30 AM)
*/
public String saveMathModel(QueryHashtable dbc, User user, String mathModelXML, String newName, String[] independentSims) throws DataAccessException, java.sql.SQLException, java.beans.PropertyVetoException, cbit.vcell.xml.XmlParseException {
//
// this invokes "update" on the database layer
//
MathModel mathModel = XmlHelper.XMLToMathModel(new XMLSource(mathModelXML));
forceDeepDirtyIfForeign(user, mathModel);
boolean isSaveAsNew = true;
//
if (newName != null) {
try {
mathModel.setName(newName);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new DataAccessException("couldn't set new name for MathModel: " + e.getMessage());
}
} else {
isSaveAsNew = false;
}
Version oldVersion = mathModel.getVersion();
MathModel origMathModel = null;
if (oldVersion != null) {
try {
String origMathModelXML = getMathModelXML(dbc, user, oldVersion.getVersionKey(), false);
origMathModel = XmlHelper.XMLToMathModel(new XMLSource(origMathModelXML));
} catch (ObjectNotFoundException nfe) {
if (isSaveAsNew) {
User foceClearVersionUser = new User("foceClearVersionUser", new KeyValue("0"));
forceDeepDirtyIfForeign(foceClearVersionUser, mathModel);
} else {
throw new DataAccessException("Stored model has been changed or removed, please use 'Save As..'");
}
}
}
boolean bSomethingChanged = false;
//
// UPDATE AND SUBSTITUTE FROM BOTTOM UP
//
// Image->Geometry
// Geometry->MathDescription
// MathDescription->Simulation,MathModel
// Simulation->MathModel
//
Simulation[] simArray = mathModel.getSimulations();
//
// if this mathModel has an image:
// save if necessary (only once) and store saved instance in hashTable
//
Hashtable<Versionable, Versionable> memoryToDatabaseHash = new Hashtable<Versionable, Versionable>();
{
VCImage memoryImage = mathModel.getMathDescription().getGeometry().getGeometrySpec().getImage();
if (memoryImage != null) {
// defaults to unchanged
memoryToDatabaseHash.put(memoryImage, memoryImage);
if (memoryImage.getKey() != null && memoryImage.getVersion().getName().equals(memoryImage.getName())) {
//
// if image had previously been saved, not been forced 'dirty', and name not changed
// compare with original image to see if "update" is required.
//
VCImage databaseImage = null;
if (origMathModel != null) {
VCImage origImage = origMathModel.getMathDescription().getGeometry().getGeometrySpec().getImage();
if (origImage != null && origImage.getKey().equals(memoryImage.getKey())) {
databaseImage = origImage;
}
}
if (databaseImage == null) {
//
// saved image not found in origMathModel (too bad), get from database.
//
databaseImage = dbServer.getDBTopLevel().getVCImage(dbc, user, memoryImage.getKey(), false);
}
if (databaseImage != null && !databaseImage.compareEqual(memoryImage)) {
KeyValue updatedImageKey = dbServer.getDBTopLevel().updateVersionable(user, memoryImage, false, true);
VCImage updatedImage = dbServer.getDBTopLevel().getVCImage(dbc, user, updatedImageKey, false);
memoryToDatabaseHash.put(memoryImage, updatedImage);
bSomethingChanged = true;
}
} else {
//
// Image hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a unique name
//
int count = 0;
fixNullImageName(memoryImage);
while (dbServer.getDBTopLevel().isNameUsed(user, VersionableType.VCImage, memoryImage.getName(), true)) {
try {
memoryImage.setName(TokenMangler.getNextRandomToken(memoryImage.getName()));
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
if (count++ > 5) {
throw new DataAccessException("failed to find unique image name '" + memoryImage.getName() + "' is last name tried");
}
}
KeyValue updatedImageKey = dbServer.getDBTopLevel().insertVersionable(user, memoryImage, memoryImage.getName(), false, true);
VCImage updatedImage = dbServer.getDBTopLevel().getVCImage(dbc, user, updatedImageKey, false);
memoryToDatabaseHash.put(memoryImage, updatedImage);
bSomethingChanged = true;
}
}
}
//
// for the Geometry:
// substitute saved Image into Geometry and
// save Geometry if necessary (only once) and store saved instance in hashtable.
//
{
Geometry memoryGeometry = mathModel.getMathDescription().getGeometry();
// defaults to unchanged
memoryToDatabaseHash.put(memoryGeometry, memoryGeometry);
boolean bMustSaveGeometry = false;
VCImage geometryImage = memoryGeometry.getGeometrySpec().getImage();
if (geometryImage != null && memoryToDatabaseHash.get(geometryImage) != geometryImage) {
//
// image had changed and was saved, load saved image into geometry and force a save of this geometry.
//
memoryGeometry.getGeometrySpec().setImage((VCImage) memoryToDatabaseHash.get(geometryImage));
geometryImage = (VCImage) memoryToDatabaseHash.get(geometryImage);
bMustSaveGeometry = true;
}
if (memoryGeometry.getKey() != null && memoryGeometry.getVersion().getName().equals(memoryGeometry.getName())) {
if (!bMustSaveGeometry) {
//
// if geometry had previously been saved, not been forced 'dirty', and name not changed
// compare with original geometry to see if "update" is required.
//
Geometry databaseGeometry = null;
if (origMathModel != null) {
Geometry origGeometry = origMathModel.getMathDescription().getGeometry();
if (origGeometry.getKey().equals(memoryGeometry.getKey())) {
databaseGeometry = origGeometry;
}
}
if (databaseGeometry == null) {
//
// saved geometry not found in origMathModel (too bad), get from database.
//
databaseGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, memoryGeometry.getKey(), false);
}
if (databaseGeometry != null && !databaseGeometry.compareEqual(memoryGeometry)) {
bMustSaveGeometry = true;
}
}
if (bMustSaveGeometry) {
KeyValue updatedImageKey = (geometryImage != null) ? (geometryImage.getKey()) : (null);
KeyValue updatedGeometryKey = dbServer.getDBTopLevel().updateVersionable(dbc, user, memoryGeometry, updatedImageKey, false, true);
Geometry updatedGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, updatedGeometryKey, false);
memoryToDatabaseHash.put(memoryGeometry, updatedGeometry);
bSomethingChanged = true;
}
} else {
//
// Geometry hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a unique name
//
int count = 0;
while (dbServer.getDBTopLevel().isNameUsed(user, VersionableType.Geometry, memoryGeometry.getName(), true)) {
try {
memoryGeometry.setName(TokenMangler.getNextRandomToken(memoryGeometry.getName()));
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
if (count++ > 5) {
throw new DataAccessException("failed to find unique geometry name '" + memoryGeometry.getName() + "' is last name tried");
}
}
KeyValue updatedImageKey = (geometryImage != null) ? (geometryImage.getKey()) : (null);
KeyValue updatedGeometryKey = dbServer.getDBTopLevel().insertVersionable(dbc, user, memoryGeometry, updatedImageKey, memoryGeometry.getName(), false, true);
Geometry updatedGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, updatedGeometryKey, false);
memoryToDatabaseHash.put(memoryGeometry, updatedGeometry);
bSomethingChanged = true;
}
}
//
// for the MathDescription:
// substitute saved geometry into MathDescription
// save MathDescription if necessary (only once) and store saved instance in hashtable.
//
MathCompareResults mathCompareResults = null;
{
MathDescription memoryMathDescription = mathModel.getMathDescription();
// defaults to unchanged
memoryToDatabaseHash.put(memoryMathDescription, memoryMathDescription);
boolean bMustSaveMathDescription = false;
Geometry scGeometry = memoryMathDescription.getGeometry();
if (scGeometry != null && memoryToDatabaseHash.get(scGeometry) != scGeometry) {
//
// geometry had changed and was saved, load saved geometry into SimulationContext (and it's MathDescription) and force a save of this SimulationContext.
//
memoryMathDescription.setGeometry((Geometry) memoryToDatabaseHash.get(scGeometry));
bMustSaveMathDescription = true;
}
MathDescription databaseMathDescription = null;
if (memoryMathDescription.getKey() != null) {
//
if (origMathModel != null) {
MathDescription origMathDescription = origMathModel.getMathDescription();
if (origMathDescription.getKey().equals(memoryMathDescription.getKey())) {
databaseMathDescription = origMathDescription;
}
}
if (databaseMathDescription == null) {
//
// saved mathDescription not found in origMathModel (too bad), get from database.
//
databaseMathDescription = dbServer.getDBTopLevel().getMathDescription(dbc, user, memoryMathDescription.getKey());
}
if (databaseMathDescription != null) {
if (!memoryMathDescription.compareEqual(databaseMathDescription)) {
bMustSaveMathDescription = true;
}
}
} else {
bMustSaveMathDescription = true;
}
if (bMustSaveMathDescription) {
//
if (databaseMathDescription != null) {
try {
mathCompareResults = MathDescription.testEquivalency(SimulationSymbolTable.createMathSymbolTableFactory(), memoryMathDescription, databaseMathDescription);
} catch (Exception e) {
e.printStackTrace(System.out);
mathCompareResults = new MathCompareResults(Decision.MathDifferent_FAILURE_UNKNOWN, "Exception: '" + e.getMessage() + "'");
System.out.println("FAILED TO COMPARE THE FOLLOWING MATH DESCRIPTIONS");
try {
System.out.println("MemoryMathDescription:\n" + ((memoryMathDescription != null) ? (memoryMathDescription.getVCML_database()) : ("null")));
System.out.println("DatabaseMathDescription:\n" + ((databaseMathDescription != null) ? (databaseMathDescription.getVCML_database()) : ("null")));
} catch (Exception e2) {
System.out.println("couldn't print math descriptions");
}
}
} else {
mathCompareResults = new MathCompareResults(Decision.MathDifferent_NOT_SAVED);
}
KeyValue updatedGeometryKey = memoryMathDescription.getGeometry().getKey();
KeyValue updatedMathDescriptionKey = null;
if (memoryMathDescription.getVersion() != null && memoryMathDescription.getVersion().getName().equals(memoryMathDescription.getName())) {
updatedMathDescriptionKey = dbServer.getDBTopLevel().updateVersionable(user, memoryMathDescription, updatedGeometryKey, false, true);
} else {
updatedMathDescriptionKey = dbServer.getDBTopLevel().insertVersionable(user, memoryMathDescription, updatedGeometryKey, memoryMathDescription.getName(), false, true);
}
MathDescription updatedMathDescription = dbServer.getDBTopLevel().getMathDescription(dbc, user, updatedMathDescriptionKey);
memoryToDatabaseHash.put(memoryMathDescription, updatedMathDescription);
bSomethingChanged = true;
} else {
mathCompareResults = new MathCompareResults(Decision.MathEquivalent_SAME_MATHDESC_AS_IN_DB);
}
}
//
for (int i = 0; simArray != null && i < simArray.length; i++) {
Simulation memorySimulation = simArray[i];
if (!memoryToDatabaseHash.containsKey(memorySimulation)) {
//
// didn't evaluate this Simulation yet.
//
// defaults to unchanged
memoryToDatabaseHash.put(memorySimulation, memorySimulation);
boolean bMustSaveSimulation = false;
MathDescription simMathDescription = memorySimulation.getMathDescription();
if (simMathDescription != null && memoryToDatabaseHash.get(simMathDescription) != simMathDescription) {
if (memoryToDatabaseHash.get(simMathDescription) != null) {
// make sure mathDescription hasn't already propagated (newer math won't be in hashtable)
//
// mathDescription had changed and was saved, load saved mathDescription into SimulationContext (and force a save)
//
memorySimulation.setMathDescription((MathDescription) memoryToDatabaseHash.get(simMathDescription));
bMustSaveSimulation = true;
}
}
Simulation databaseSimulation = null;
//
if (memorySimulation.getKey() != null) {
if (origMathModel != null) {
for (int j = 0; j < origMathModel.getNumSimulations(); j++) {
if (origMathModel.getSimulations(j).getKey().equals(memorySimulation.getKey())) {
databaseSimulation = origMathModel.getSimulations(j);
break;
}
}
}
if (databaseSimulation == null) {
//
// saved simulation not found in origBioModel (too bad), get from database.
//
databaseSimulation = dbServer.getDBTopLevel().getSimulation(dbc, user, memorySimulation.getKey());
}
if (databaseSimulation != null && !databaseSimulation.compareEqual(memorySimulation)) {
bMustSaveSimulation = true;
}
if (!memorySimulation.getVersion().getName().equals(memorySimulation.getName())) {
// name was changed.
bMustSaveSimulation = true;
}
} else {
// never been saved.
bMustSaveSimulation = true;
}
if (bMustSaveSimulation) {
KeyValue updatedMathDescriptionKey = memorySimulation.getMathDescription().getKey();
KeyValue updatedSimulationKey = null;
boolean bSimMathematicallyEquivalent = false;
if (databaseSimulation != null) {
//
// if to be forced "independent", then set equivalent to false
//
boolean bForceIndependent = false;
for (int j = 0; independentSims != null && j < independentSims.length; j++) {
if (independentSims[j].equals(memorySimulation.getName())) {
bForceIndependent = true;
}
}
// check for math equivalency
try {
bSimMathematicallyEquivalent = !bForceIndependent && Simulation.testEquivalency(memorySimulation, databaseSimulation, mathCompareResults);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new DataAccessException(e.getMessage());
}
//
if (bSimMathematicallyEquivalent) {
VCSimulationIdentifier vcSimulationIdentifier = databaseSimulation.getSimulationInfo().getAuthoritativeVCSimulationIdentifier();
SimulationStatusPersistent simStatus = dbServer.getSimulationStatus(vcSimulationIdentifier.getSimulationKey());
if (simStatus == null || !simStatus.getHasData()) {
bSimMathematicallyEquivalent = false;
}
}
}
if (memorySimulation.getKey() != null && memorySimulation.getVersion().getName().equals(memorySimulation.getName())) {
// name not changed, update simulation (but pass in database Simulation to check for parent-equivalence)
updatedSimulationKey = dbServer.getDBTopLevel().updateVersionable(user, memorySimulation, updatedMathDescriptionKey, false, bSimMathematicallyEquivalent, true);
} else {
// name changed, insert simulation (but pass in database Simulation to check for parent-equivalence)
updatedSimulationKey = dbServer.getDBTopLevel().insertVersionable(user, memorySimulation, updatedMathDescriptionKey, memorySimulation.getName(), false, bSimMathematicallyEquivalent, true);
}
Simulation updatedSimulation = dbServer.getDBTopLevel().getSimulation(dbc, user, updatedSimulationKey);
memoryToDatabaseHash.put(memorySimulation, updatedSimulation);
bSomethingChanged = true;
}
}
}
if (bSomethingChanged || origMathModel == null || !mathModel.compareEqual(origMathModel)) {
//
// create new MathModelMetaData and save to server
//
KeyValue mathDescriptionKey = ((MathDescription) memoryToDatabaseHash.get(mathModel.getMathDescription())).getKey();
KeyValue[] simKeys = new KeyValue[mathModel.getNumSimulations()];
for (int i = 0; i < mathModel.getNumSimulations(); i++) {
simKeys[i] = ((Simulation) memoryToDatabaseHash.get(mathModel.getSimulations(i))).getKey();
}
MathModelMetaData mathModelMetaData = null;
if (oldVersion == null) {
mathModelMetaData = new MathModelMetaData(mathDescriptionKey, simKeys, mathModel.getName(), mathModel.getDescription(), mathModel.getOutputFunctionContext().getOutputFunctionsList());
} else {
mathModelMetaData = new MathModelMetaData(oldVersion, mathDescriptionKey, simKeys, mathModel.getOutputFunctionContext().getOutputFunctionsList());
if (!mathModel.getDescription().equals(oldVersion.getAnnot())) {
try {
mathModelMetaData.setDescription(mathModel.getDescription());
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
}
}
MathModelMetaData updatedMathModelMetaData = null;
if (mathModel.getVersion() == null || !mathModel.getVersion().getName().equals(mathModel.getName())) {
KeyValue updatedMathModelKey = dbServer.getDBTopLevel().insertVersionable(user, mathModelMetaData, null, /*hack*/
mathModel.getName(), false, true);
updatedMathModelMetaData = dbServer.getDBTopLevel().getMathModelMetaData(dbc, user, updatedMathModelKey);
} else {
KeyValue updatedMathModelKey = dbServer.getDBTopLevel().updateVersionable(user, mathModelMetaData, null, /*hack*/
false, true);
updatedMathModelMetaData = dbServer.getDBTopLevel().getMathModelMetaData(dbc, user, updatedMathModelKey);
}
//
// (THIS IS THE REALLY SCARY PART...NOT GETTING A FRESH VIEW OF EVERYTING FROM THE DATABASE FOR CREATING THE XML)
//
// mathModelXML = getMathModelXML(user,updatedMathModelMetaData.getVersion().getVersionKey());
MathModel updatedMathModel = new MathModel(updatedMathModelMetaData.getVersion());
updatedMathModel.setMathDescription((MathDescription) memoryToDatabaseHash.get(mathModel.getMathDescription()));
for (int i = 0; i < mathModel.getNumSimulations(); i++) {
updatedMathModel.addSimulation((Simulation) memoryToDatabaseHash.get(mathModel.getSimulations(i)));
}
updatedMathModel.getOutputFunctionContext().setOutputFunctions(mathModel.getOutputFunctionContext().getOutputFunctionsList());
mathModelXML = cbit.vcell.xml.XmlHelper.mathModelToXML(updatedMathModel);
dbServer.insertVersionableChildSummary(user, VersionableType.MathModelMetaData, updatedMathModel.getVersion().getVersionKey(), updatedMathModel.createMathModelChildSummary().toDatabaseSerialization());
dbServer.insertVersionableXML(user, VersionableType.MathModelMetaData, updatedMathModel.getVersion().getVersionKey(), mathModelXML);
return mathModelXML;
} else {
return mathModelXML;
}
}
Also used :
MathModel(cbit.vcell.mathmodel.MathModel)
VCSimulationIdentifier(cbit.vcell.solver.VCSimulationIdentifier)
User(org.vcell.util.document.User)
KeyValue(org.vcell.util.document.KeyValue)
MathDescription(cbit.vcell.math.MathDescription)
VCImage(cbit.image.VCImage)
PropertyVetoException(java.beans.PropertyVetoException)
Versionable(org.vcell.util.document.Versionable)
Version(org.vcell.util.document.Version)
MathCompareResults(cbit.vcell.math.MathCompareResults)
DataAccessException(org.vcell.util.DataAccessException)
Hashtable(java.util.Hashtable)
QueryHashtable(cbit.sql.QueryHashtable)
SimulationStatusPersistent(cbit.vcell.server.SimulationStatusPersistent)
MathModelMetaData(cbit.vcell.mathmodel.MathModelMetaData)
ObjectNotFoundException(org.vcell.util.ObjectNotFoundException)
PropertyVetoException(java.beans.PropertyVetoException)
XmlParseException(cbit.vcell.xml.XmlParseException)
DataAccessException(org.vcell.util.DataAccessException)
MappingException(cbit.vcell.mapping.MappingException)
PropertyVetoException(java.beans.PropertyVetoException)
Geometry(cbit.vcell.geometry.Geometry)
Simulation(cbit.vcell.solver.Simulation)
ObjectNotFoundException(org.vcell.util.ObjectNotFoundException)
XMLSource(cbit.vcell.xml.XMLSource)
Example 58 with Version
use of org.vcell.util.document.Version in project vcell by virtualcell.
the class ServerDocumentManager method saveBioModel.
/**
* Insert the method's description here.
* Creation date: (10/28/00 12:08:30 AM)
*/
public String saveBioModel(QueryHashtable dbc, User user, String bioModelXML, String newName, String[] independentSims) throws DataAccessException, java.sql.SQLException, java.beans.PropertyVetoException, MappingException, cbit.vcell.xml.XmlParseException {
long start = System.currentTimeMillis();
//
// this invokes "update" on the database layer
//
BioModel bioModel = XmlHelper.XMLToBioModel(new XMLSource(bioModelXML));
forceDeepDirtyIfForeign(user, bioModel);
boolean isSaveAsNew = true;
//
if (newName != null) {
try {
bioModel.setName(newName);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new DataAccessException("couldn't set new name for BioModel: " + e.getMessage());
}
} else {
isSaveAsNew = false;
}
Version oldVersion = bioModel.getVersion();
BioModel origBioModel = null;
if (oldVersion != null) {
try {
String origBioModelXML = getBioModelXML(dbc, user, oldVersion.getVersionKey(), false);
origBioModel = XmlHelper.XMLToBioModel(new XMLSource(origBioModelXML));
} catch (ObjectNotFoundException nfe) {
if (isSaveAsNew) {
User foceClearVersionUser = new User("foceClearVersionUser", new KeyValue("0"));
forceDeepDirtyIfForeign(foceClearVersionUser, bioModel);
} else {
throw new DataAccessException("Stored model has been changed or removed, please use 'Save As..'");
}
}
}
boolean bSomethingChanged = false;
//
// verify that there are no orphaned Simulations (that belonged to Applications that have null mathDescriptions ... incomplete mappings)
//
// the workspace is responsible for cleaning up Simulations
//
{
Simulation[] sims = bioModel.getSimulations();
SimulationContext[] scs = bioModel.getSimulationContexts();
for (int i = 0; sims != null && i < sims.length; i++) {
boolean bFound = false;
for (int j = 0; scs != null && j < scs.length; j++) {
if (scs[j].getMathDescription() == sims[i].getMathDescription()) {
bFound = true;
}
}
if (!bFound) {
throw new RuntimeException("Error: Simulation " + sims[i].getName() + " cannot be saved, no Application exists with same MathDescription");
}
}
}
//
// UPDATE AND SUBSTITUTE FROM BOTTOM UP
//
// Image->Geometry
// Geometry->SimContext,MathDescription
// MathDescription->Simulation,SimulationContext
// Model->BioModel
// Simulation->BioModel
// SimContext->BioModel
// VCMetaData->BioModel
//
Simulation[] simArray = bioModel.getSimulations();
SimulationContext[] scArray = bioModel.getSimulationContexts();
// Hashtable mathEquivHash = new Hashtable();
long roundtripTimer = 0;
long l1 = 0;
long l2 = 0;
//
// for each image (anywhere in document):
// save if necessary (only once) and store saved instance in hashTable
//
Hashtable<Versionable, Versionable> memoryToDatabaseHash = new Hashtable<Versionable, Versionable>();
for (int i = 0; scArray != null && i < scArray.length; i++) {
VCImage memoryImage = scArray[i].getGeometry().getGeometrySpec().getImage();
if (memoryImage != null) {
if (!memoryToDatabaseHash.containsKey(memoryImage)) {
//
// didn't evaluate this image yet.
//
// defaults to unchanged
memoryToDatabaseHash.put(memoryImage, memoryImage);
if (memoryImage.getKey() != null && memoryImage.getVersion().getName().equals(memoryImage.getName())) {
//
// if image had previously been saved, not been forced 'dirty', and name not changed
// compare with original image to see if "update" is required.
//
VCImage databaseImage = null;
if (origBioModel != null) {
for (int j = 0; j < origBioModel.getNumSimulationContexts(); j++) {
VCImage origImage = origBioModel.getSimulationContext(j).getGeometry().getGeometrySpec().getImage();
if (origImage != null && origImage.getKey().equals(memoryImage.getKey())) {
databaseImage = origImage;
}
}
}
if (databaseImage == null) {
//
// saved image not found in origBioModel (too bad), get from database.
//
l1 = System.currentTimeMillis();
databaseImage = dbServer.getDBTopLevel().getVCImage(dbc, user, memoryImage.getKey(), false);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
}
if (databaseImage != null && !databaseImage.compareEqual(memoryImage)) {
KeyValue updatedImageKey = dbServer.getDBTopLevel().updateVersionable(user, memoryImage, false, true);
l1 = System.currentTimeMillis();
VCImage updatedImage = dbServer.getDBTopLevel().getVCImage(dbc, user, updatedImageKey, false);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
memoryToDatabaseHash.put(memoryImage, updatedImage);
bSomethingChanged = true;
}
} else {
//
// Image hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a unique name
//
int count = 0;
fixNullImageName(memoryImage);
while (dbServer.getDBTopLevel().isNameUsed(user, VersionableType.VCImage, memoryImage.getName(), true)) {
try {
memoryImage.setName(TokenMangler.getNextRandomToken(memoryImage.getName()));
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
if (count++ > 5) {
throw new DataAccessException("failed to find unique image name '" + memoryImage.getName() + "' is last name tried");
}
}
KeyValue updatedImageKey = dbServer.getDBTopLevel().insertVersionable(user, memoryImage, memoryImage.getName(), false, true);
l1 = System.currentTimeMillis();
VCImage updatedImage = dbServer.getDBTopLevel().getVCImage(dbc, user, updatedImageKey, false);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
memoryToDatabaseHash.put(memoryImage, updatedImage);
bSomethingChanged = true;
}
}
}
}
//
for (int i = 0; scArray != null && i < scArray.length; i++) {
Geometry memoryGeometry = scArray[i].getGeometry();
if (!memoryToDatabaseHash.containsKey(memoryGeometry)) {
//
// didn't evaluate this geometry yet.
//
// defaults to unchanged
memoryToDatabaseHash.put(memoryGeometry, memoryGeometry);
boolean bMustSaveGeometry = false;
VCImage geometryImage = memoryGeometry.getGeometrySpec().getImage();
if (geometryImage != null && memoryToDatabaseHash.get(geometryImage) != geometryImage) {
//
// image had changed and was saved, load saved image into geometry and force a save of this geometry.
//
memoryGeometry.getGeometrySpec().setImage((VCImage) memoryToDatabaseHash.get(geometryImage));
geometryImage = (VCImage) memoryToDatabaseHash.get(geometryImage);
bMustSaveGeometry = true;
}
if (memoryGeometry.getKey() != null && memoryGeometry.getVersion().getName().equals(memoryGeometry.getName())) {
if (!bMustSaveGeometry) {
//
// if geometry had previously been saved, not been forced 'dirty', and name not changed
// compare with original geometry to see if "update" is required.
//
Geometry databaseGeometry = null;
if (origBioModel != null) {
for (int j = 0; j < origBioModel.getNumSimulationContexts(); j++) {
Geometry origGeometry = origBioModel.getSimulationContext(j).getGeometry();
if (origGeometry != null && origGeometry.getKey().equals(memoryGeometry.getKey())) {
databaseGeometry = origGeometry;
}
}
}
if (databaseGeometry == null) {
//
// saved geometry not found in origBioModel (too bad), get from database.
//
l1 = System.currentTimeMillis();
databaseGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, memoryGeometry.getKey(), false);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
}
if (databaseGeometry != null && !databaseGeometry.compareEqual(memoryGeometry)) {
bMustSaveGeometry = true;
}
if (!bMustSaveGeometry && memoryGeometry.getDimension() > 0) {
GeometrySurfaceDescription geomSurfDescr = memoryGeometry.getGeometrySurfaceDescription();
SurfaceClass[] surfClassArr = geomSurfDescr.getSurfaceClasses();
for (int j = 0; surfClassArr != null && j < surfClassArr.length; j++) {
if (surfClassArr[j].getKey() == null) {
bMustSaveGeometry = true;
break;
}
}
}
}
if (bMustSaveGeometry) {
KeyValue updatedImageKey = (geometryImage != null) ? (geometryImage.getKey()) : (null);
KeyValue updatedGeometryKey = dbServer.getDBTopLevel().updateVersionable(dbc, user, memoryGeometry, updatedImageKey, false, true);
l1 = System.currentTimeMillis();
Geometry updatedGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, updatedGeometryKey, false);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
memoryToDatabaseHash.put(memoryGeometry, updatedGeometry);
bSomethingChanged = true;
}
} else {
//
// Geometry hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a unique name
//
int count = 0;
while (dbServer.getDBTopLevel().isNameUsed(user, VersionableType.Geometry, memoryGeometry.getName(), true)) {
try {
memoryGeometry.setName(TokenMangler.getNextRandomToken(memoryGeometry.getName()));
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
if (count++ > 5) {
throw new DataAccessException("failed to find unique geometry name '" + memoryGeometry.getName() + "' is last name tried");
}
}
KeyValue updatedImageKey = (geometryImage != null) ? (geometryImage.getKey()) : (null);
KeyValue updatedGeometryKey = dbServer.getDBTopLevel().insertVersionable(dbc, user, memoryGeometry, updatedImageKey, memoryGeometry.getName(), false, true);
l1 = System.currentTimeMillis();
Geometry updatedGeometry = dbServer.getDBTopLevel().getGeometry(dbc, user, updatedGeometryKey, false);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
memoryToDatabaseHash.put(memoryGeometry, updatedGeometry);
bSomethingChanged = true;
}
}
}
//
// for each MathDescription in document:
// substitute saved geometry's into SimulationContext and
// save SimulationContext if necessary (only once) and store saved instance in hashtable.
//
Hashtable<MathDescription, MathCompareResults> mathEquivalencyHash = new Hashtable<MathDescription, MathCompareResults>();
for (int i = 0; scArray != null && i < scArray.length; i++) {
MathDescription memoryMathDescription = scArray[i].getMathDescription();
if (!memoryToDatabaseHash.containsKey(memoryMathDescription)) {
//
// didn't evaluate this SimulationContext yet.
//
// defaults to unchanged
memoryToDatabaseHash.put(memoryMathDescription, memoryMathDescription);
boolean bMustSaveMathDescription = false;
Geometry scGeometry = memoryMathDescription.getGeometry();
if (scGeometry != null && memoryToDatabaseHash.get(scGeometry) != scGeometry) {
//
// geometry had changed and was saved, load saved geometry into SimulationContext (and it's MathDescription) and force a save of this SimulationContext.
//
memoryMathDescription.setGeometry((Geometry) memoryToDatabaseHash.get(scGeometry));
bMustSaveMathDescription = true;
}
MathDescription databaseMathDescription = null;
if (memoryMathDescription.getKey() != null) {
//
if (origBioModel != null) {
for (int j = 0; j < origBioModel.getNumSimulationContexts(); j++) {
MathDescription math = origBioModel.getSimulationContext(j).getMathDescription();
if (math.getKey().equals(memoryMathDescription.getKey())) {
databaseMathDescription = math;
}
}
}
if (databaseMathDescription == null) {
//
// saved mathDescription not found in origBioModel (too bad), get from database.
//
l1 = System.currentTimeMillis();
databaseMathDescription = dbServer.getDBTopLevel().getMathDescription(dbc, user, memoryMathDescription.getKey());
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
}
if (databaseMathDescription != null && !databaseMathDescription.compareEqual(memoryMathDescription)) {
bMustSaveMathDescription = true;
}
} else {
bMustSaveMathDescription = true;
}
if (bMustSaveMathDescription) {
MathCompareResults mathCompareResults = null;
if (databaseMathDescription != null) {
try {
mathCompareResults = MathDescription.testEquivalency(SimulationSymbolTable.createMathSymbolTableFactory(), memoryMathDescription, databaseMathDescription);
if (mathCompareResults != null && !mathCompareResults.isEquivalent() && (mathCompareResults.decision.equals(Decision.MathDifferent_DIFFERENT_NUMBER_OF_VARIABLES) || mathCompareResults.decision.equals(Decision.MathDifferent_VARIABLE_NOT_FOUND_AS_FUNCTION))) {
//
// if there is a different number of variables or cannot find variables by name (even considering change of state variables)
// then try the VCell 4.8 generated math.
//
MathDescription mathDesc_4_8 = new MathMapping_4_8(scArray[i]).getMathDescription();
mathCompareResults = MathDescription.testEquivalency(SimulationSymbolTable.createMathSymbolTableFactory(), mathDesc_4_8, databaseMathDescription);
}
} catch (Exception e) {
e.printStackTrace(System.out);
mathCompareResults = new MathCompareResults(Decision.MathDifferent_FAILURE_UNKNOWN, "Exception: '" + e.getMessage() + "'");
System.out.println("FAILED TO COMPARE THE FOLLOWING MATH DESCRIPTIONS");
try {
System.out.println("MemoryMathDescription:\n" + ((memoryMathDescription != null) ? (memoryMathDescription.getVCML_database()) : ("null")));
System.out.println("DatabaseMathDescription:\n" + ((databaseMathDescription != null) ? (databaseMathDescription.getVCML_database()) : ("null")));
} catch (Exception e2) {
System.out.println("couldn't print math descriptions");
}
}
} else {
mathCompareResults = new MathCompareResults(Decision.MathDifferent_NOT_SAVED);
}
//
// MathDescription hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a any name (doens't have to be unique ... mathDescription is not a top-level versionable).
//
KeyValue updatedGeometryKey = memoryMathDescription.getGeometry().getKey();
KeyValue updatedMathDescriptionKey = null;
if (memoryMathDescription.getVersion() != null && memoryMathDescription.getVersion().getName().equals(memoryMathDescription.getName())) {
updatedMathDescriptionKey = dbServer.getDBTopLevel().updateVersionable(user, memoryMathDescription, updatedGeometryKey, false, true);
} else {
updatedMathDescriptionKey = dbServer.getDBTopLevel().insertVersionable(user, memoryMathDescription, updatedGeometryKey, memoryMathDescription.getName(), false, true);
}
l1 = System.currentTimeMillis();
MathDescription updatedMathDescription = dbServer.getDBTopLevel().getMathDescription(dbc, user, updatedMathDescriptionKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
memoryToDatabaseHash.put(memoryMathDescription, updatedMathDescription);
mathEquivalencyHash.put(updatedMathDescription, mathCompareResults);
bSomethingChanged = true;
} else {
mathEquivalencyHash.put(memoryMathDescription, new MathCompareResults(Decision.MathEquivalent_SAME_MATHDESC_AS_IN_DB));
}
}
}
//
// update physiology
//
{
Model memoryModel = bioModel.getModel();
// preload with unchanged.
memoryToDatabaseHash.put(memoryModel, memoryModel);
if (memoryModel.getKey() != null && memoryModel.getVersion().getName().equals(memoryModel.getName())) {
//
// if Model had previously been saved, not been forced 'dirty', and name not changed
// compare with original Model to see if "update" is required.
//
Model databaseModel = null;
if (origBioModel != null) {
if (origBioModel.getModel().getKey().equals(memoryModel.getKey())) {
databaseModel = origBioModel.getModel();
}
}
if (databaseModel == null) {
//
// saved model not found in origBioModel (too bad), get from database.
//
l1 = System.currentTimeMillis();
databaseModel = dbServer.getDBTopLevel().getModel(dbc, user, memoryModel.getKey());
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
}
if (databaseModel != null && !databaseModel.compareEqual(memoryModel)) {
KeyValue updatedModelKey = dbServer.getDBTopLevel().updateVersionable(user, memoryModel, false, true);
l1 = System.currentTimeMillis();
Model updatedModel = dbServer.getDBTopLevel().getModel(dbc, user, updatedModelKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
memoryToDatabaseHash.put(memoryModel, updatedModel);
bSomethingChanged = true;
}
} else {
//
// Model hasn't been saved, has been renamed, or has been forced 'dirty'
// insert it with a any name (doens't have to be unique ... mathDescription is not a top-level versionable).
//
KeyValue updatedModelKey = dbServer.getDBTopLevel().insertVersionable(user, memoryModel, memoryModel.getName(), false, true);
l1 = System.currentTimeMillis();
Model updatedModel = dbServer.getDBTopLevel().getModel(dbc, user, updatedModelKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
memoryToDatabaseHash.put(memoryModel, updatedModel);
bSomethingChanged = true;
}
}
//
for (int i = 0; scArray != null && i < scArray.length; i++) {
SimulationContext memorySimContext = scArray[i];
if (!memoryToDatabaseHash.containsKey(memorySimContext)) {
//
// didn't evaluate this SimulationContext yet.
//
// defaults to unchanged
memoryToDatabaseHash.put(memorySimContext, memorySimContext);
boolean bMustSaveSimContext = false;
Geometry scGeometry = memorySimContext.getGeometry();
if (scGeometry != null && memoryToDatabaseHash.get(scGeometry) != scGeometry) {
//
// geometry had changed and was saved, load saved geometry into SimulationContext (and force a save)
//
memorySimContext.setGeometry((Geometry) memoryToDatabaseHash.get(scGeometry));
bMustSaveSimContext = true;
}
MathDescription scMathDescription = memorySimContext.getMathDescription();
if (scMathDescription != null && memoryToDatabaseHash.get(scMathDescription) != scMathDescription) {
//
// mathDescription had changed and was saved, load saved mathDescription into SimulationContext (and force a save)
//
memorySimContext.setMathDescription((MathDescription) memoryToDatabaseHash.get(scMathDescription));
bMustSaveSimContext = true;
}
Model scModel = memorySimContext.getModel();
if (scModel != null && memoryToDatabaseHash.get(scModel) != scModel) {
//
// model had changed and was saved, load saved model into SimulationContext (and force a save)
//
memorySimContext.setModel((Model) memoryToDatabaseHash.get(scModel));
bMustSaveSimContext = true;
}
if (memorySimContext.getKey() != null && memorySimContext.getVersion().getName().equals(memorySimContext.getName())) {
if (!bMustSaveSimContext) {
//
// if SimulationContext had previously been saved, not been forced 'dirty', and name not changed
// compare with original SimulationContext to see if "update" is required.
//
SimulationContext databaseSimContext = null;
if (origBioModel != null) {
for (int j = 0; j < origBioModel.getNumSimulationContexts(); j++) {
if (origBioModel.getSimulationContext(j).getKey().equals(memorySimContext.getKey())) {
databaseSimContext = origBioModel.getSimulationContext(j);
}
}
}
if (databaseSimContext == null) {
//
// saved geometry not found in origBioModel (too bad), get from database.
//
l1 = System.currentTimeMillis();
databaseSimContext = dbServer.getDBTopLevel().getSimulationContext(dbc, user, memorySimContext.getKey());
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
}
if (databaseSimContext != null && !databaseSimContext.compareEqual(memorySimContext)) {
bMustSaveSimContext = true;
}
}
if (bMustSaveSimContext) {
KeyValue updatedGeometryKey = memorySimContext.getGeometry().getKey();
KeyValue updatedMathDescriptionKey = memorySimContext.getMathDescription().getKey();
Model updatedModel = memorySimContext.getModel();
KeyValue updatedSimContextKey = dbServer.getDBTopLevel().updateVersionable(user, memorySimContext, updatedMathDescriptionKey, updatedModel, updatedGeometryKey, false, true);
l1 = System.currentTimeMillis();
SimulationContext updatedSimContext = dbServer.getDBTopLevel().getSimulationContext(dbc, user, updatedSimContextKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
//
// make sure mathDescription is a single reference (for this app and all of it's Simulations).
//
updatedSimContext.setMathDescription((MathDescription) memorySimContext.getMathDescription());
memoryToDatabaseHash.put(memorySimContext, updatedSimContext);
bSomethingChanged = true;
}
} else {
//
// SimulationContext hasn't been saved, has been renamed, or has been forced 'dirty'
//
KeyValue updatedGeometryKey = memorySimContext.getGeometry().getKey();
KeyValue updatedMathDescriptionKey = memorySimContext.getMathDescription().getKey();
Model updatedModel = memorySimContext.getModel();
KeyValue updatedSimContextKey = dbServer.getDBTopLevel().insertVersionable(user, memorySimContext, updatedMathDescriptionKey, updatedModel, updatedGeometryKey, memorySimContext.getName(), false, true);
l1 = System.currentTimeMillis();
SimulationContext updatedSimContext = dbServer.getDBTopLevel().getSimulationContext(dbc, user, updatedSimContextKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
//
// make sure mathDescription is a single reference (for this app and all of it's Simulations).
//
updatedSimContext.setMathDescription((MathDescription) memorySimContext.getMathDescription());
memoryToDatabaseHash.put(memorySimContext, updatedSimContext);
bSomethingChanged = true;
}
}
}
//
for (int i = 0; simArray != null && i < simArray.length; i++) {
Simulation memorySimulation = simArray[i];
if (!memoryToDatabaseHash.containsKey(memorySimulation)) {
//
// didn't evaluate this Simulation yet.
//
// defaults to unchanged
memoryToDatabaseHash.put(memorySimulation, memorySimulation);
boolean bMustSaveSimulation = false;
MathDescription simMathDescription = memorySimulation.getMathDescription();
if (simMathDescription != null && memoryToDatabaseHash.get(simMathDescription) != simMathDescription) {
if (memoryToDatabaseHash.get(simMathDescription) != null) {
// make sure mathDescription hasn't already propagated (newer math won't be in hashtable)
//
// mathDescription had changed and was saved, load saved mathDescription into Simulation (and force a save)
//
memorySimulation.setMathDescription((MathDescription) memoryToDatabaseHash.get(simMathDescription));
bMustSaveSimulation = true;
}
}
Simulation databaseSimulation = null;
//
if (memorySimulation.getKey() != null) {
if (origBioModel != null) {
for (int j = 0; j < origBioModel.getNumSimulations(); j++) {
if (origBioModel.getSimulation(j).getKey().equals(memorySimulation.getKey())) {
databaseSimulation = origBioModel.getSimulation(j);
}
}
}
if (databaseSimulation == null) {
//
// saved simulation not found in origBioModel (too bad), get from database.
//
l1 = System.currentTimeMillis();
databaseSimulation = dbServer.getDBTopLevel().getSimulation(dbc, user, memorySimulation.getKey());
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
}
if (databaseSimulation != null) {
if (!memorySimulation.compareEqual(databaseSimulation)) {
bMustSaveSimulation = true;
}
}
if (!memorySimulation.getVersion().getName().equals(memorySimulation.getName())) {
// name was changed.
bMustSaveSimulation = true;
}
} else {
// never been saved.
bMustSaveSimulation = true;
}
if (bMustSaveSimulation) {
boolean bMathematicallyEquivalent = false;
if (databaseSimulation != null) {
//
// if to be forced "independent", then set equivalent to false
//
boolean bForceIndependent = false;
for (int j = 0; independentSims != null && j < independentSims.length; j++) {
if (independentSims[j].equals(memorySimulation.getName())) {
bForceIndependent = true;
}
}
//
// check for math equivalency first
//
MathCompareResults mathCompareResults = mathEquivalencyHash.get(memorySimulation.getMathDescription());
bMathematicallyEquivalent = !bForceIndependent && Simulation.testEquivalency(memorySimulation, databaseSimulation, mathCompareResults);
//
if (bMathematicallyEquivalent) {
VCSimulationIdentifier vcSimulationIdentifier = databaseSimulation.getSimulationInfo().getAuthoritativeVCSimulationIdentifier();
SimulationStatusPersistent simStatus = dbServer.getSimulationStatus(vcSimulationIdentifier.getSimulationKey());
if (simStatus == null || !simStatus.getHasData()) {
bMathematicallyEquivalent = false;
}
}
}
KeyValue updatedMathDescriptionKey = memorySimulation.getMathDescription().getKey();
KeyValue updatedSimulationKey = null;
if (memorySimulation.getKey() != null && memorySimulation.getVersion().getName().equals(memorySimulation.getName())) {
// name not changed, update simulation (but pass in database Simulation to check for parent-equivalence)
updatedSimulationKey = dbServer.getDBTopLevel().updateVersionable(user, memorySimulation, updatedMathDescriptionKey, false, bMathematicallyEquivalent, true);
} else {
// name changed, insert simulation (but pass in database Simulation to check for parent-equivalence)
updatedSimulationKey = dbServer.getDBTopLevel().insertVersionable(user, memorySimulation, updatedMathDescriptionKey, memorySimulation.getName(), false, bMathematicallyEquivalent, true);
}
l1 = System.currentTimeMillis();
Simulation updatedSimulation = dbServer.getDBTopLevel().getSimulation(dbc, user, updatedSimulationKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
//
// make sure mathDescription is a single reference (for an app and all of it's Simulations).
//
updatedSimulation.setMathDescription((MathDescription) memorySimulation.getMathDescription());
memoryToDatabaseHash.put(memorySimulation, updatedSimulation);
bSomethingChanged = true;
}
}
}
boolean bMustSaveVCMetaData = false;
if (origBioModel != null) {
//
// for the VCMetaData in the document:
// save VCMetaData if necessary (only once) and store saved instance in hashtable.
//
// The persisted VCMetaData doesn't have any foreign keys
// (when annotating a simulation ... we don't point to the simulation,
// we use the text-based VCID that is stored in URIBindingList in the XML serialization
//
// Therefore, there are no additional dependencies that we have to update during the
// incremental save and force propagation to save the VCMetaData.
//
VCMetaData memoryVCMetaData = bioModel.getVCMetaData();
VCMetaData databaseVCMetaData = origBioModel.getVCMetaData();
//
if (databaseVCMetaData == null || !databaseVCMetaData.compareEquals(memoryVCMetaData)) {
bMustSaveVCMetaData = true;
bSomethingChanged = true;
}
}
if (bSomethingChanged || origBioModel == null || !bioModel.compareEqual(origBioModel)) {
//
// create new BioModelMetaData and save to server
//
KeyValue modelKey = ((Model) memoryToDatabaseHash.get(bioModel.getModel())).getKey();
KeyValue[] scKeys = new KeyValue[bioModel.getNumSimulationContexts()];
for (int i = 0; i < bioModel.getNumSimulationContexts(); i++) {
scKeys[i] = ((SimulationContext) memoryToDatabaseHash.get(bioModel.getSimulationContext(i))).getKey();
}
KeyValue[] simKeys = new KeyValue[bioModel.getNumSimulations()];
for (int i = 0; i < bioModel.getNumSimulations(); i++) {
simKeys[i] = ((Simulation) memoryToDatabaseHash.get(bioModel.getSimulation(i))).getKey();
}
// @TODO Add VC_METADATA table ... pointed to by VC_BIOMODEL (metadataref on delete cascade)
// @TODO Write script to populate VC_METADATA from VC_MIRIAM
// @TODO save VCMetaData from this BioModel into VC_METADATA .. stick in memoryToDatabaseHash
//
BioModelMetaData bioModelMetaData = null;
String vcMetaDataXML = XmlHelper.vcMetaDataToXML(bioModel.getVCMetaData(), bioModel);
if (oldVersion == null) {
bioModelMetaData = new BioModelMetaData(modelKey, scKeys, simKeys, vcMetaDataXML, bioModel.getName(), bioModel.getDescription());
} else {
bioModelMetaData = new BioModelMetaData(oldVersion, modelKey, scKeys, simKeys, vcMetaDataXML);
if (!bioModel.getDescription().equals(oldVersion.getAnnot())) {
try {
bioModelMetaData.setDescription(bioModel.getDescription());
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
}
}
}
// bioModelMetaData.setMIRIAMAnnotation(bioModel.getMIRIAMAnnotation());
BioModelMetaData updatedBioModelMetaData = null;
if (bioModel.getVersion() == null || !bioModel.getVersion().getName().equals(bioModel.getName())) {
KeyValue updatedBioModelKey = dbServer.getDBTopLevel().insertVersionable(user, bioModelMetaData, null, /*hack*/
bioModel.getName(), false, true);
l1 = System.currentTimeMillis();
updatedBioModelMetaData = dbServer.getDBTopLevel().getBioModelMetaData(dbc, user, updatedBioModelKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
} else {
KeyValue updatedBioModelKey = dbServer.getDBTopLevel().updateVersionable(user, bioModelMetaData, null, /*hack*/
false, true);
l1 = System.currentTimeMillis();
updatedBioModelMetaData = dbServer.getDBTopLevel().getBioModelMetaData(dbc, user, updatedBioModelKey);
l2 = System.currentTimeMillis();
roundtripTimer += l2 - l1;
}
//
// (THIS IS THE REALLY SCAREY PART...NOT GETTING A FRESH VIEW OF EVERYTING FROM THE DATABASE FOR CREATING THE XML)
//
// bioModelXML = getBioModelXML(user,updatedBioModelMetaData.getVersion().getVersionKey());
BioModel updatedBioModel = new BioModel(updatedBioModelMetaData.getVersion());
// updatedBioModel.setMIRIAMAnnotation(updatedBioModelMetaData.getMIRIAMAnnotation());
updatedBioModel.setModel((Model) memoryToDatabaseHash.get(bioModel.getModel()));
for (int i = 0; i < bioModel.getNumSimulationContexts(); i++) {
updatedBioModel.addSimulationContext((SimulationContext) memoryToDatabaseHash.get(bioModel.getSimulationContext(i)));
}
for (int i = 0; i < bioModel.getNumSimulations(); i++) {
updatedBioModel.addSimulation((Simulation) memoryToDatabaseHash.get(bioModel.getSimulation(i)));
}
updatedBioModel.setVCMetaData(XmlHelper.xmlToVCMetaData(updatedBioModel.getVCMetaData(), updatedBioModel, vcMetaDataXML));
// TODO must replace this with proper persistance.
updatedBioModel.getPathwayModel().merge(bioModel.getPathwayModel());
updatedBioModel.getRelationshipModel().merge(bioModel.getRelationshipModel());
bioModelXML = cbit.vcell.xml.XmlHelper.bioModelToXML(updatedBioModel);
dbServer.insertVersionableChildSummary(user, VersionableType.BioModelMetaData, updatedBioModel.getVersion().getVersionKey(), updatedBioModel.createBioModelChildSummary().toDatabaseSerialization());
dbServer.insertVersionableXML(user, VersionableType.BioModelMetaData, updatedBioModel.getVersion().getVersionKey(), bioModelXML);
System.out.println("------------------------------> Total time: " + ((double) (System.currentTimeMillis() - start)) / 1000);
System.out.println("------------------------------> Time spent on roundtrip: " + ((double) roundtripTimer) / 1000);
return bioModelXML;
} else {
System.out.println("------------------------------> Total time: " + ((double) (System.currentTimeMillis() - start)) / 1000);
System.out.println("------------------------------> Time spent on roundtrip: " + ((double) roundtripTimer) / 1000);
return bioModelXML;
}
}
Also used :
VCSimulationIdentifier(cbit.vcell.solver.VCSimulationIdentifier)
User(org.vcell.util.document.User)
KeyValue(org.vcell.util.document.KeyValue)
GeometrySurfaceDescription(cbit.vcell.geometry.surface.GeometrySurfaceDescription)
SurfaceClass(cbit.vcell.geometry.SurfaceClass)
MathDescription(cbit.vcell.math.MathDescription)
VCImage(cbit.image.VCImage)
BioModelMetaData(cbit.vcell.biomodel.BioModelMetaData)
PropertyVetoException(java.beans.PropertyVetoException)
Versionable(org.vcell.util.document.Versionable)
VCMetaData(cbit.vcell.biomodel.meta.VCMetaData)
Version(org.vcell.util.document.Version)
MathCompareResults(cbit.vcell.math.MathCompareResults)
DataAccessException(org.vcell.util.DataAccessException)
Hashtable(java.util.Hashtable)
QueryHashtable(cbit.sql.QueryHashtable)
SimulationStatusPersistent(cbit.vcell.server.SimulationStatusPersistent)
MathMapping_4_8(cbit.vcell.mapping.vcell_4_8.MathMapping_4_8)
SimulationContext(cbit.vcell.mapping.SimulationContext)
ObjectNotFoundException(org.vcell.util.ObjectNotFoundException)
PropertyVetoException(java.beans.PropertyVetoException)
XmlParseException(cbit.vcell.xml.XmlParseException)
DataAccessException(org.vcell.util.DataAccessException)
MappingException(cbit.vcell.mapping.MappingException)
Geometry(cbit.vcell.geometry.Geometry)
Simulation(cbit.vcell.solver.Simulation)
BioModel(cbit.vcell.biomodel.BioModel)
ObjectNotFoundException(org.vcell.util.ObjectNotFoundException)
MathModel(cbit.vcell.mathmodel.MathModel)
BioModel(cbit.vcell.biomodel.BioModel)
Model(cbit.vcell.model.Model)
XMLSource(cbit.vcell.xml.XMLSource)
Example 59 with Version
use of org.vcell.util.document.Version in project vcell by virtualcell.
the class SimContextTable method getInfo.
/**
* This method was created in VisualAge.
* @return cbit.vcell.geometry.GeometryInfo
* @param rset java.sql.ResultSet
* @param log cbit.vcell.server.SessionLog
*/
public VersionInfo getInfo(ResultSet rset, Connection con) throws SQLException, DataAccessException {
KeyValue mathRef = null;
java.math.BigDecimal mathRefValue = rset.getBigDecimal(SimContextTable.table.mathRef.toString());
if (!rset.wasNull()) {
mathRef = new KeyValue(mathRefValue);
}
KeyValue geomRef = new KeyValue(rset.getBigDecimal(SimContextTable.table.geometryRef.toString()));
KeyValue modelRef = new KeyValue(rset.getBigDecimal(SimContextTable.table.modelRef.toString()));
java.math.BigDecimal groupid = rset.getBigDecimal(VersionTable.privacy_ColumnName);
Version version = getVersion(rset, DbDriver.getGroupAccessFromGroupID(con, groupid));
String softwareVersion = rset.getString(SoftwareVersionTable.table.softwareVersion.toString());
return new SimulationContextInfo(mathRef, geomRef, modelRef, version, VCellSoftwareVersion.fromString(softwareVersion));
}
Also used :
BigDecimal(java.math.BigDecimal)
KeyValue(org.vcell.util.document.KeyValue)
Version(org.vcell.util.document.Version)
VCellSoftwareVersion(org.vcell.util.document.VCellSoftwareVersion)
SimulationContextInfo(cbit.vcell.mapping.SimulationContextInfo)
Example 60 with Version
use of org.vcell.util.document.Version in project vcell by virtualcell.
the class SimulationDbDriver method insertVersionableInit.
/**
* This method was created in VisualAge.
* @return cbit.image.VCImage
* @param user cbit.vcell.server.User
* @param image cbit.image.VCImage
*/
protected SimulationVersion insertVersionableInit(InsertHashtable hash, Connection con, User user, Versionable versionable, String name, String annot, boolean bVersion, boolean bMathematicallyEquivalent) throws DataAccessException, SQLException, RecordChangedException {
SimulationVersion dbSimulationVersion = ((Simulation) versionable).getSimulationVersion();
Version newVersion = insertVersionableInit(hash, con, user, versionable, name, annot, bVersion);
//
// point to oldest mathematically equivalent ancestor, this will be used for all identification (status/data).
//
KeyValue parentSimRef = null;
if (bMathematicallyEquivalent) {
if (dbSimulationVersion == null) {
throw new RuntimeException("Simulation must have been saved for bMathematicallyEquivalent to be true");
}
if (dbSimulationVersion.getParentSimulationReference() != null) {
// //
// // mathematically equivalent, prior link is transitive (B->C and A==B, then A->C)
// //
parentSimRef = dbSimulationVersion.getParentSimulationReference();
} else {
// //
// // mathematically equivalent, no prior link (A==B, then A->B)
// //
parentSimRef = dbSimulationVersion.getVersionKey();
}
}
return new SimulationVersion(newVersion.getVersionKey(), newVersion.getName(), newVersion.getOwner(), newVersion.getGroupAccess(), newVersion.getBranchPointRefKey(), newVersion.getBranchID(), newVersion.getDate(), newVersion.getFlag(), newVersion.getAnnot(), parentSimRef);
}
Also used :
SimulationVersion(org.vcell.util.document.SimulationVersion)
KeyValue(org.vcell.util.document.KeyValue)
Simulation(cbit.vcell.solver.Simulation)
SimulationVersion(org.vcell.util.document.SimulationVersion)
Version(org.vcell.util.document.Version)
Aggregations
Version (org.vcell.util.document.Version)74
VCellSoftwareVersion (org.vcell.util.document.VCellSoftwareVersion)27
DataAccessException (org.vcell.util.DataAccessException)24
KeyValue (org.vcell.util.document.KeyValue)22
BigDecimal (java.math.BigDecimal)17
Geometry (cbit.vcell.geometry.Geometry)13
SimulationVersion (org.vcell.util.document.SimulationVersion)12
PropertyVetoException (java.beans.PropertyVetoException)10
User (org.vcell.util.document.User)10
VersionableTypeVersion (org.vcell.util.document.VersionableTypeVersion)10
Element (org.jdom.Element)9
MathDescription (cbit.vcell.math.MathDescription)8
RedistributionVersion (cbit.vcell.solvers.mb.MovingBoundarySolverOptions.RedistributionVersion)8
SimulationContext (cbit.vcell.mapping.SimulationContext)7
ResultSet (java.sql.ResultSet)7
Statement (java.sql.Statement)7
ImageException (cbit.image.ImageException)6
Simulation (cbit.vcell.solver.Simulation)6
VersionFlag (org.vcell.util.document.VersionFlag)6
Model (cbit.vcell.model.Model)5
