END_TEST
START_TEST (test_UnitDefinition_isVariantOfVolume_2)
{
Unit_t *dim = Unit_create(2, 4);
Unit_setKind( dim , UnitKind_forName("dimensionless") );
Unit_t *u = UnitDefinition_createUnit(UD);
fail_unless( !UnitDefinition_isVariantOfVolume(UD) );
Unit_setKind(u, UNIT_KIND_METRE);
Unit_setExponent(u, 3);
fail_unless( UnitDefinition_isVariantOfVolume(UD) );
Unit_setScale(u, 100);
fail_unless( UnitDefinition_isVariantOfVolume(UD) );
Unit_setMultiplier(u, 5);
fail_unless( UnitDefinition_isVariantOfVolume(UD) );
Unit_setOffset(u, -5);
fail_unless( UnitDefinition_isVariantOfVolume(UD) );
Unit_setExponent(u, 2);
fail_unless( !UnitDefinition_isVariantOfVolume(UD) );
Unit_setExponent(u, 3);
UnitDefinition_addUnit( UD, dim );
fail_unless( UnitDefinition_isVariantOfVolume(UD) );
}
END_TEST
START_TEST (test_SBMLDocument_setLevelAndVersion_Error)
{
SBMLDocument_t *d = SBMLDocument_create();
SBMLDocument_setLevelAndVersion(d, 2, 1);
Model_t *m1 = Model_create(2, 1);
/* add unitDefinition */
Unit_t * u = Unit_create(2, 1);
Unit_setKind(u, UnitKind_forName("mole"));
Unit_setOffset(u, 3.2);
UnitDefinition_t *ud =
UnitDefinition_create(2, 1);
UnitDefinition_setId(ud, "ud");
UnitDefinition_addUnit(ud, u);
Model_addUnitDefinition(m1, ud);
SBMLDocument_setModel(d, m1);
fail_unless(SBMLDocument_setLevelAndVersionStrict(d,2,2) == 0);
fail_unless(SBMLDocument_setLevelAndVersionStrict(d,2,3) == 0);
fail_unless(SBMLDocument_setLevelAndVersionStrict(d,1,2) == 0);
fail_unless(SBMLDocument_setLevelAndVersionStrict(d,1,1) == 0);
SBMLDocument_free(d);
}
END_TEST
START_TEST (test_UnitDefinition_isVariantOfTime)
{
Unit_t *dim = Unit_create(2, 4);
Unit_setKind( dim , UnitKind_forName("dimensionless") );
Unit_t *u = UnitDefinition_createUnit(UD);
fail_unless( !UnitDefinition_isVariantOfTime(UD) );
Unit_setKind(u, UNIT_KIND_SECOND);
Unit_setExponent(u, 1);
fail_unless( UnitDefinition_isVariantOfTime(UD) );
Unit_setScale(u, -10);
fail_unless( UnitDefinition_isVariantOfTime(UD) );
Unit_setMultiplier(u, 10);
fail_unless( UnitDefinition_isVariantOfTime(UD) );
Unit_setOffset(u, 30);
fail_unless( UnitDefinition_isVariantOfTime(UD) );
Unit_setExponent(u, 2);
fail_unless( !UnitDefinition_isVariantOfTime(UD) );
Unit_setExponent(u, 1);
UnitDefinition_addUnit( UD, dim );
fail_unless( UnitDefinition_isVariantOfTime(UD) );
Unit_free(dim);
}
END_TEST
START_TEST (test_UnitDefinition_isVariantOfSubstancePerTime_3)
{
UnitDefinition_t *ud =
UnitDefinition_create(2, 2);
Unit_t *dim = Unit_create(2, 2);
Unit_setKind( dim , UnitKind_forName("dimensionless") );
Unit_t *perTime = UnitDefinition_createUnit(ud);
Unit_setKind( perTime , UnitKind_forName("second") );
Unit_setExponent( perTime, -1);
Unit_t *u = UnitDefinition_createUnit(ud);
fail_unless( !UnitDefinition_isVariantOfSubstancePerTime(ud) );
Unit_setKind(u, UNIT_KIND_GRAM);
Unit_setExponent(u, 1);
fail_unless( UnitDefinition_isVariantOfSubstancePerTime(ud) );
Unit_setScale(u, -1);
Unit_setScale(perTime, -1);
fail_unless( UnitDefinition_isVariantOfSubstancePerTime(ud) );
Unit_setMultiplier(u, 2);
fail_unless( UnitDefinition_isVariantOfSubstancePerTime(ud) );
Unit_setOffset(u, 3);
fail_unless( UnitDefinition_isVariantOfSubstancePerTime(ud) );
Unit_setExponent(u, -3);
fail_unless( !UnitDefinition_isVariantOfSubstancePerTime(ud) );
Unit_setExponent(u, 1);
Unit_setExponent(perTime, -3);
fail_unless( !UnitDefinition_isVariantOfSubstancePerTime(ud) );
Unit_setExponent(perTime, -1);
UnitDefinition_addUnit( ud, dim );
fail_unless( UnitDefinition_isVariantOfSubstancePerTime(ud) );
UnitDefinition_free(ud);
Unit_free(dim);
}
END_TEST
START_TEST (test_Unit_setKind2)
{
int i = Unit_setKind(U, UnitKind_forName("litre"));
fail_unless( i == LIBSBML_OPERATION_SUCCESS );
fail_unless( Unit_isSetKind(U) );
}
END_TEST
START_TEST (test_UnitDefinition_getUnit)
{
Unit_t *mole = Unit_create(2, 4);
Unit_t *litre = Unit_create(2, 4);
Unit_t *second = Unit_create(2, 4);
Unit_setKind( mole , UnitKind_forName("mole") );
Unit_setKind( litre , UnitKind_forName("litre") );
Unit_setKind( second, UnitKind_forName("second") );
Unit_setScale (mole , -3);
Unit_setExponent(litre , -1);
Unit_setExponent(second, -1);
UnitDefinition_addUnit( UD, mole );
UnitDefinition_addUnit( UD, litre );
UnitDefinition_addUnit( UD, second );
Unit_free(mole);
Unit_free(litre);
Unit_free(second);
fail_unless( UnitDefinition_getNumUnits(UD) == 3 );
mole = UnitDefinition_getUnit(UD, 0);
litre = UnitDefinition_getUnit(UD, 1);
second = UnitDefinition_getUnit(UD, 2);
fail_unless( Unit_getKind(mole) == UNIT_KIND_MOLE );
fail_unless( Unit_getKind(litre) == UNIT_KIND_LITRE );
fail_unless( Unit_getKind(second) == UNIT_KIND_SECOND );
fail_unless( Unit_getScale(mole) == -3 );
fail_unless( Unit_getExponent(litre) == -1 );
fail_unless( Unit_getExponent(second) == -1 );
}
END_TEST
START_TEST (test_L3_Unit_kind)
{
char *kind = "mole";
fail_unless( !Unit_isSetKind(U) );
Unit_setKind(U, UnitKind_forName(kind));
fail_unless( Unit_getKind(U) == UNIT_KIND_MOLE );
fail_unless( Unit_isSetKind(U) );
}
/*
* Predicate for testing whether a given string corresponds to a
* predefined UnitKind_t enumeration value.
*
* @return nonzero (for true) if string is the name of a valid
* UnitKind_t enumeration value, zero (0) otherwise.
*/
LIBSBML_EXTERN
int
UnitKind_isValidUnitKindString (const char *string, unsigned int level, unsigned int version)
{
UnitKind_t uk = UnitKind_forName(string);
if (level == 1)
{
return uk != UNIT_KIND_INVALID;
}
else
{
if (uk == UNIT_KIND_METER || uk == UNIT_KIND_LITER)
return 0;
else if (version > 1 && uk == UNIT_KIND_CELSIUS)
return 0;
else
return uk != UNIT_KIND_INVALID;
}
}
END_TEST
START_TEST (test_UnitDefinition_printUnits)
{
UnitDefinition_t *ud = UnitDefinition_create(2, 4);
UnitDefinition_setId(ud, "mmls");
Unit_t *perTime = UnitDefinition_createUnit(ud);
Unit_setKind( perTime , UnitKind_forName("second") );
Unit_setExponent( perTime, -1);
char * ud_str = UnitDefinition_printUnits(ud, 0);
fail_unless(!strcmp(ud_str,
"second (exponent = -1, multiplier = 1, scale = 0)"));
char * ud_str1 = UnitDefinition_printUnits(ud, 1);
fail_unless(!strcmp(ud_str1, "(1 second)^-1"));
UnitDefinition_t *ud1 = UnitDefinition_create(2, 4);
UnitDefinition_setId(ud1, "mmls");
Unit_t *u = UnitDefinition_createUnit(ud1);
Unit_setKind(u, UNIT_KIND_KILOGRAM);
Unit_setExponent(u, 1);
Unit_setScale(u, 2);
Unit_setMultiplier(u, 3.0);
char * ud_str2 = UnitDefinition_printUnits(ud1, 0);
fail_unless(!strcmp(ud_str2,
"kilogram (exponent = 1, multiplier = 3, scale = 2)"));
char * ud_str3 = UnitDefinition_printUnits(ud1, 1);
fail_unless(!strcmp(ud_str3, "(300 kilogram)^1"));
safe_free(ud_str);
safe_free(ud_str1);
safe_free(ud_str2);
safe_free(ud_str3);
UnitDefinition_free(ud);
UnitDefinition_free(ud1);
}
END_TEST
START_TEST (test_UnitKind_forName)
{
fail_unless( UnitKind_forName("ampere") == UNIT_KIND_AMPERE , NULL );
fail_unless( UnitKind_forName("becquerel") == UNIT_KIND_BECQUEREL, NULL );
fail_unless( UnitKind_forName("candela") == UNIT_KIND_CANDELA , NULL );
fail_unless( UnitKind_forName("Celsius") == UNIT_KIND_CELSIUS , NULL );
fail_unless( UnitKind_forName("coulomb") == UNIT_KIND_COULOMB , NULL );
fail_unless( UnitKind_forName("dimensionless") == UNIT_KIND_DIMENSIONLESS,
NULL);
fail_unless( UnitKind_forName("farad") == UNIT_KIND_FARAD , NULL );
fail_unless( UnitKind_forName("gram") == UNIT_KIND_GRAM , NULL );
fail_unless( UnitKind_forName("gray") == UNIT_KIND_GRAY , NULL );
fail_unless( UnitKind_forName("henry") == UNIT_KIND_HENRY , NULL );
fail_unless( UnitKind_forName("hertz") == UNIT_KIND_HERTZ , NULL );
fail_unless( UnitKind_forName("item") == UNIT_KIND_ITEM , NULL );
fail_unless( UnitKind_forName("joule") == UNIT_KIND_JOULE , NULL );
fail_unless( UnitKind_forName("katal") == UNIT_KIND_KATAL , NULL );
fail_unless( UnitKind_forName("kelvin") == UNIT_KIND_KELVIN , NULL );
fail_unless( UnitKind_forName("kilogram") == UNIT_KIND_KILOGRAM , NULL );
fail_unless( UnitKind_forName("liter") == UNIT_KIND_LITER , NULL );
fail_unless( UnitKind_forName("litre") == UNIT_KIND_LITRE , NULL );
fail_unless( UnitKind_forName("lumen") == UNIT_KIND_LUMEN , NULL );
fail_unless( UnitKind_forName("lux") == UNIT_KIND_LUX , NULL );
fail_unless( UnitKind_forName("meter") == UNIT_KIND_METER , NULL );
fail_unless( UnitKind_forName("metre") == UNIT_KIND_METRE , NULL );
fail_unless( UnitKind_forName("mole") == UNIT_KIND_MOLE , NULL );
fail_unless( UnitKind_forName("newton") == UNIT_KIND_NEWTON , NULL );
fail_unless( UnitKind_forName("ohm") == UNIT_KIND_OHM , NULL );
fail_unless( UnitKind_forName("pascal") == UNIT_KIND_PASCAL , NULL );
fail_unless( UnitKind_forName("radian") == UNIT_KIND_RADIAN , NULL );
fail_unless( UnitKind_forName("second") == UNIT_KIND_SECOND , NULL );
fail_unless( UnitKind_forName("siemens") == UNIT_KIND_SIEMENS , NULL );
fail_unless( UnitKind_forName("sievert") == UNIT_KIND_SIEVERT , NULL );
fail_unless( UnitKind_forName("steradian") == UNIT_KIND_STERADIAN, NULL );
fail_unless( UnitKind_forName("tesla") == UNIT_KIND_TESLA , NULL );
fail_unless( UnitKind_forName("volt") == UNIT_KIND_VOLT , NULL );
fail_unless( UnitKind_forName("watt") == UNIT_KIND_WATT , NULL );
fail_unless( UnitKind_forName("weber") == UNIT_KIND_WEBER , NULL );
fail_unless( UnitKind_forName(NULL) == UNIT_KIND_INVALID, NULL );
fail_unless( UnitKind_forName("") == UNIT_KIND_INVALID, NULL );
fail_unless( UnitKind_forName("foobar") == UNIT_KIND_INVALID, NULL );
}
/* in L1 and L2 there were built in values for key units
* such as 'volume', 'length', 'area', 'substance' and 'time'
* In L3 these have been removed - thus if a model uses one of these
* it needs a unitDefinition to define it
*/
void
Model::addDefinitionsForDefaultUnits()
{
/* create a list of unit values */
IdList unitsUsed;
unsigned int n;
bool implicitVolume = false;
bool implicitArea = false;
bool implicitLength = false;
bool implicitSubstance = false;
for (n = 0; n < getNumCompartments(); n++)
{
if (getCompartment(n)->isSetUnits())
{
unitsUsed.append(getCompartment(n)->getUnits());
}
else
{
if (getCompartment(n)->getSpatialDimensions() == 3)
{
implicitVolume = true;
getCompartment(n)->setUnits("volume");
}
else if (getCompartment(n)->getSpatialDimensions() == 2)
{
implicitArea = true;
getCompartment(n)->setUnits("area");
}
else if (getCompartment(n)->getSpatialDimensions() == 1)
{
implicitLength = true;
getCompartment(n)->setUnits("length");
}
}
}
for (n = 0; n < getNumSpecies(); n++)
{
if (getSpecies(n)->isSetSubstanceUnits())
{
unitsUsed.append(getSpecies(n)->getSubstanceUnits());
}
else
{
implicitSubstance = true;
getSpecies(n)->setSubstanceUnits("substance");
}
if (getSpecies(n)->isSetSpatialSizeUnits())
unitsUsed.append(getSpecies(n)->getSpatialSizeUnits());
}
for (n = 0; n < getNumParameters(); n++)
{
if (getParameter(n)->isSetUnits())
unitsUsed.append(getParameter(n)->getUnits());
}
if (getUnitDefinition("volume") == NULL)
{
if (unitsUsed.contains("volume") || implicitVolume)
{
UnitDefinition * ud = createUnitDefinition();
ud->setId("volume");
Unit * u = ud->createUnit();
u->setKind(UnitKind_forName("litre"));
u->setScale(0);
u->setExponent(1.0);
u->setMultiplier(1.0);
setVolumeUnits("volume");
}
else
{
setVolumeUnits("litre");
}
}
else
{
setVolumeUnits("volume");
}
if (getUnitDefinition("substance") == NULL)
{
if (unitsUsed.contains("substance") || implicitSubstance)
{
UnitDefinition * ud = createUnitDefinition();
ud->setId("substance");
Unit * u = ud->createUnit();
u->setKind(UnitKind_forName("mole"));
u->setScale(0);
u->setExponent(1.0);
u->setMultiplier(1.0);
setSubstanceUnits("substance");
setExtentUnits("substance");
}
else
{
setSubstanceUnits("mole");
setExtentUnits("mole");
}
}
else
{
setSubstanceUnits("substance");
setExtentUnits("substance");
}
if (getUnitDefinition("area") == NULL)
{
UnitDefinition * ud = createUnitDefinition();
ud->setId("area");
Unit * u = ud->createUnit();
u->setKind(UnitKind_forName("metre"));
u->setScale(0);
u->setExponent(2.0);
u->setMultiplier(1.0);
setAreaUnits("area");
}
else
{
setAreaUnits("area");
}
if (getUnitDefinition("length") == NULL)
{
if (unitsUsed.contains("length") || implicitLength)
{
UnitDefinition * ud = createUnitDefinition();
ud->setId("length");
Unit * u = ud->createUnit();
u->setKind(UnitKind_forName("metre"));
u->setScale(0);
u->setExponent(1.0);
u->setMultiplier(1.0);
setLengthUnits("length");
}
else
{
setLengthUnits("metre");
}
}
else
{
setLengthUnits("length");
}
if (getUnitDefinition("time") == NULL)
{
setTimeUnits("second");
}
else
{
setTimeUnits("time");
}
}
void
Model::dealWithModelUnits()
{
UnitRefsFilter filter;
List * elements = getAllElements(&filter);
unsigned int n = 0;
unsigned int num = elements->getSize();
if (isSetVolumeUnits())
{
std::string volume = getVolumeUnits();
// if in an L3 model a user used volume as an id of a UnitDefinition
// but they declared the volume units of teh model to be something
// else then the UD with id volume is nothing to do with the
// L2 interpretation of volume
// so replace that UD and all references to it
if (volume != "volume")
{
UnitDefinition * existingUD = removeUnitDefinition("volume");
if (existingUD != NULL)
{
std::string newSubsName = "volumeFromOriginal";
existingUD->setId(newSubsName);
SBase* obj;
for (n = 0; n < num; n++)
{
obj = (SBase*)(elements->get(n));
obj->renameUnitSIdRefs("volume", newSubsName);
}
addUnitDefinition(existingUD);
}
}
UnitDefinition * ud = getUnitDefinition(volume) != NULL ?
getUnitDefinition(volume)->clone() : NULL;
if (ud != NULL)
{
ud->setId("volume");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(volume.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("volume");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetAreaUnits())
{
std::string area = getAreaUnits();
// if in an L3 model a user used area as an id of a UnitDefinition
// but they declared the area units of teh model to be something
// else then the UD with id area is nothing to do with the
// L2 interpretation of area
// so replace that UD and all references to it
if (area != "area")
{
UnitDefinition * existingUD = removeUnitDefinition("area");
if (existingUD != NULL)
{
std::string newSubsName = "areaFromOriginal";
existingUD->setId(newSubsName);
SBase* obj;
for (n = 0; n < num; n++)
{
obj = (SBase*)(elements->get(n));
obj->renameUnitSIdRefs("area", newSubsName);
}
addUnitDefinition(existingUD);
}
}
UnitDefinition * ud = getUnitDefinition(area) != NULL ?
getUnitDefinition(area)->clone() : NULL;
if (ud != NULL)
{
ud->setId("area");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(area.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("area");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetLengthUnits())
{
std::string length = getLengthUnits();
// if in an L3 model a user used length as an id of a UnitDefinition
// but they declared the length units of teh model to be something
// else then the UD with id length is nothing to do with the
// L2 interpretation of length
// so replace that UD and all references to it
if (length != "length")
{
UnitDefinition * existingUD = removeUnitDefinition("length");
if (existingUD != NULL)
{
std::string newSubsName = "lengthFromOriginal";
existingUD->setId(newSubsName);
SBase* obj;
for (n = 0; n < num; n++)
{
obj = (SBase*)(elements->get(n));
obj->renameUnitSIdRefs("length", newSubsName);
}
addUnitDefinition(existingUD);
}
}
UnitDefinition * ud = getUnitDefinition(length) != NULL ?
getUnitDefinition(length)->clone() : NULL;
if (ud != NULL)
{
ud->setId("length");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(length.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("length");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetSubstanceUnits())
{
std::string substance = getSubstanceUnits();
// if in an L3 model a user used substance as an id of a UnitDefinition
// but they declared the substance units of teh model to be something
// else then the UD with id substance is nothing to do with the
// L2 interpretation of substance
// so replace that UD and all references to it
if (substance != "substance")
{
UnitDefinition * existingUD = removeUnitDefinition("substance");
if (existingUD != NULL)
{
std::string newSubsName = "substanceFromOriginal";
existingUD->setId(newSubsName);
SBase* obj;
for (n = 0; n < num; n++)
{
obj = (SBase*)(elements->get(n));
obj->renameUnitSIdRefs("substance", newSubsName);
}
addUnitDefinition(existingUD);
}
}
UnitDefinition * ud = getUnitDefinition(substance) != NULL ?
getUnitDefinition(substance)->clone() : NULL;
if (ud != NULL)
{
ud->setId("substance");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(substance.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("substance");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetTimeUnits())
{
std::string time = getTimeUnits();
// if in an L3 model a user used time as an id of a UnitDefinition
// but they declared the time units of teh model to be something
// else then the UD with id time is nothing to do with the
// L2 interpretation of time
// so replace that UD and all references to it
if (time != "time")
{
UnitDefinition * existingUD = removeUnitDefinition("time");
if (existingUD != NULL)
{
std::string newSubsName = "timeFromOriginal";
existingUD->setId(newSubsName);
SBase* obj;
for (n = 0; n < num; n++)
{
obj = (SBase*)(elements->get(n));
obj->renameUnitSIdRefs("time", newSubsName);
}
addUnitDefinition(existingUD);
}
}
UnitDefinition * ud = getUnitDefinition(time) != NULL ?
getUnitDefinition(time)->clone() : NULL;
if (ud != NULL)
{
ud->setId("time");
}
else
{
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("time");
Unit *u = ud->createUnit();
u->initDefaults();
u->setKind(UnitKind_forName(time.c_str()));
}
addUnitDefinition(ud);
}
}
void
Model::dealWithModelUnits()
{
if (isSetVolumeUnits())
{
std::string volume = getVolumeUnits();
UnitDefinition * ud = removeUnitDefinition(volume);
if (ud != NULL)
{
ud->setId("volume");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(volume.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("volume");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetAreaUnits())
{
std::string area = getAreaUnits();
UnitDefinition * ud = removeUnitDefinition(area);
if (ud != NULL)
{
ud->setId("area");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(area.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("area");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetLengthUnits())
{
std::string length = getLengthUnits();
UnitDefinition * ud = removeUnitDefinition(length);
if (ud != NULL)
{
ud->setId("length");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(length.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("length");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetSubstanceUnits())
{
std::string substance = getSubstanceUnits();
UnitDefinition * ud = removeUnitDefinition(substance);
if (ud != NULL)
{
ud->setId("substance");
}
else
{
Unit *u = new Unit(getSBMLNamespaces());
u->initDefaults();
u->setKind(UnitKind_forName(substance.c_str()));
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("substance");
ud->addUnit(u);
}
addUnitDefinition(ud);
}
if (isSetTimeUnits())
{
std::string time = getTimeUnits();
UnitDefinition * ud = removeUnitDefinition(time);
if (ud != NULL)
{
ud->setId("time");
}
else
{
ud = new UnitDefinition(getSBMLNamespaces());
ud->setId("time");
Unit *u = ud->createUnit();
u->initDefaults();
u->setKind(UnitKind_forName(time.c_str()));
}
addUnitDefinition(ud);
}
}
