void
MaLaESTest::testMaLaESObject()
{
iface::cellml_services::MaLaESTransform* mt =
mMaLaESBootstrap->compileTransformer
(
L"opengroup: (\r\n"
L"closegroup: )\r\n"
L"abs: #prec[H]fabs(#expr1)\r\n"
L"and: #prec[20]#exprs[&&]\r\n"
L"arccos: #prec[H]acos(#expr1)\r\n"
L"arccosh: #prec[H]acosh(#expr1)\r\n"
L"arccot: #prec[1000(900)]atan(1.0/#expr1)\r\n"
L"arccoth: #prec[1000(900)]atanh(1.0/#expr1)\r\n"
L"arccsc: #prec[1000(900)]asin(1/#expr1)\r\n"
L"arccsch: #prec[1000(900)]asinh(1/#expr1)\r\n"
L"arcsec: #prec[1000(900)]acos(1/#expr1)\r\n"
L"arcsech: #prec[1000(900)]acosh(1/#expr1)\r\n"
L"arcsin: #prec[H]asin(#expr1)\r\n"
L"arcsinh: #prec[H]asinh(#expr1)\r\n"
L"arctan: #prec[H]atan(#expr1)\r\n"
L"arctanh: #prec[H]atanh(#expr1)\r\n"
L"ceiling: #prec[H]ceil(#expr1)\r\n"
L"cos: #prec[H]cos(#expr1)\r\n"
L"cosh: #prec[H]cosh(#expr1)\r\n"
L"cot: #prec[900(0)]1.0/tan(#expr1)\r\n"
L"coth: #prec[900(0)]1.0/tanh(#expr1)\r\n"
L"csc: #prec[900(0)]1.0/sin(#expr1)\r\n"
L"csch: #prec[900(0)]1.0/sinh(#expr1)\r\n"
L"diff: #lookupDiffVariable\r\n"
L"divide: #prec[900]#expr1/#expr2\r\n"
L"eq: #prec[30]#exprs[==]\r\n"
L"exp: #prec[H]exp(#expr1)\r\n"
L"factorial: #prec[H]factorial(#expr1)\r\n"
L"factorof: #prec[30(900)]#expr1 % #expr2 == 0\r\n"
L"floor: #prec[H]floor(#expr1)\r\n"
L"gcd: #prec[H]gcd_multi(#count, #exprs[, ])\r\n"
L"geq: #prec[30]#exprs[>=]\r\n"
L"gt: #prec[30]#exprs[>]\r\n"
L"implies: #prec[10(950)]!#expr1 || #expr2\r\n"
L"int: #prec[H]defint(func#unique1, BOUND, CONSTANTS, RATES, VARIABLES, #bvarIndex)#supplement double func#unique1(double* BOUND, double* CONSTANTS, double* RATES, double* VARIABLES) { return #expr1; }\r\n"
L"lcm: #prec[H]lcm_multi(#count, #exprs[, ])\r\n"
L"leq: #prec[30]#exprs[<=]\r\n"
L"ln: #prec[H]log(#expr1)\r\n"
L"log: #prec[H]arbitrary_log(#expr1, #logbase)\r\n"
L"lt: #prec[30]#exprs[<]\r\n"
L"max: #prec[H]multi_max(#count, #exprs[, ])\r\n"
L"min: #prec[H]multi_min(#count, #exprs[, ])\r\n"
L"minus: #prec[500]#expr1 - #expr2\r\n"
L"neq: #prec[30]#expr1 != #expr2\r\n"
L"not: #prec[950]!#expr1\r\n"
L"or: #prec[10]#exprs[||]\r\n"
L"plus: #prec[500]#exprs[+]\r\n"
L"power: #prec[H]pow(#expr1, #expr2)\r\n"
L"quotient: #prec[900(0)](int)(#expr1) / (int)(#expr2)\r\n"
L"rem: #prec[900(0)](int)(#expr1) % (int)(#expr2)\r\n"
L"root: #prec[1000(900)]pow(#expr1, 1.0 / #degree)\r\n"
L"sec: #prec[900(0)]1.0 / cos(#expr1)\r\n"
L"sech: #prec[900(0)]1.0 / cosh(#expr1)\r\n"
L"sin: #prec[H]sin(#expr1)\r\n"
L"sinh: #prec[H]sinh(#expr1)\r\n"
L"tan: #prec[H]tan(#expr1)\r\n"
L"tanh: #prec[H]tanh(#expr1)\r\n"
L"times: #prec[900]#exprs[*]\r\n"
L"unary_minus: #prec[950]-#expr1\r\n"
L"units_conversion: #prec[500(900)]#expr1*#expr2 + #expr3\r\n"
L"units_conversion_offset: #prec[500]#expr1+#expr2\r\n"
L"units_conversion_factor: #prec[900]#expr1*#expr2\r\n"
L"xor: #prec[25(30)](#expr1 != 0) ^ (#expr2 != 0)\r\n"
);
iface::cellml_api::CellMLBootstrap* cellbs = CreateCellMLBootstrap();
iface::cellml_api::DOMModelLoader* ml = cellbs->modelLoader();
cellbs->release_ref();
iface::cellml_api::Model* m = ml->loadFromURL
(BASE_DIRECTORY L"glycolysis_pathway_1997.xml");
ml->release_ref();
iface::cellml_services::CeVASBootstrap* cb =
CreateCeVASBootstrap();
iface::cellml_services::CeVAS* cev = cb->createCeVASForModel(m);
cb->release_ref();
iface::cellml_services::CUSESBootstrap* cub = CreateCUSESBootstrap();
iface::cellml_services::CUSES* cu =
cub->createCUSESForModel(m, false);
cub->release_ref();
iface::cellml_services::AnnotationToolService* ats =
CreateAnnotationToolService();
iface::cellml_services::AnnotationSet* as = ats->createAnnotationSet();
ats->release_ref();
iface::cellml_api::CellMLComponentSet* ccs = m->localComponents();
iface::cellml_api::CellMLComponent * glcC, * gts, * gp;
glcC = ccs->getComponent(L"Glc_C");
gts = ccs->getComponent(L"glucose_transport_system");
gp = ccs->getComponent(L"glucose_phosphorylation");
ccs->release_ref();
iface::cellml_api::CellMLVariableSet* vs = glcC->variables();
iface::cellml_api::CellMLVariable * vglcC, * vdelta_Glc_C_rxn1, * vdelta_Glc_C_rxn2;
vglcC = vs->getVariable(L"Glc_C");
vs->release_ref();
vs = gts->variables();
vdelta_Glc_C_rxn1 = vs->getVariable(L"delta_Glc_C_rxn1");
vs->release_ref();
vs = gp->variables();
vdelta_Glc_C_rxn2 = vs->getVariable(L"delta_Glc_C_rxn2");
vs->release_ref();
as->setStringAnnotation(vglcC, L"expression_d1",
L"first_derivative_of_glcC");
as->setStringAnnotation(vglcC, L"expression",
L"glcC");
as->setStringAnnotation(vdelta_Glc_C_rxn1, L"expression",
L"delta_Glc_C_rxn1");
as->setStringAnnotation(vdelta_Glc_C_rxn2, L"expression",
L"delta_Glc_C_rxn2");
iface::cellml_api::MathList* matl =
glcC->math();
iface::cellml_api::MathMLElementIterator* mei = matl->iterate();
iface::mathml_dom::MathMLElement* math = mei->next();
DECLARE_QUERY_INTERFACE(mmel, math, mathml_dom::MathMLMathElement);
math->release_ref();
mei->release_ref();
matl->release_ref();
iface::mathml_dom::MathMLElement* expr = mmel->getArgument(1);
mmel->release_ref();
iface::cellml_services::MaLaESResult* mr =
mt->transform(cev, cu, as, expr, glcC, NULL, NULL, 0);
CPPUNIT_ASSERT(mr);
std::wstring str = mr->compileErrors();
CPPUNIT_ASSERT_EQUAL(std::wstring(L""), str);
str = mr->expression();
CPPUNIT_ASSERT_EQUAL(std::wstring(L"first_derivative_of_glcC*0.00100000==1000.00*(1000.00*(delta_Glc_C_rxn1*0.00100000)+delta_Glc_C_rxn2)"), str);
uint32_t l = mr->supplementariesLength();
CPPUNIT_ASSERT_EQUAL(0, (int)l);
std::set<iface::cellml_api::CellMLVariable*> invVars;
iface::cellml_api::CellMLVariableIterator* cvi = mr->iterateInvolvedVariables();
iface::cellml_api::CellMLVariable* var;
while ((var = cvi->nextVariable()) != NULL)
{
CPPUNIT_ASSERT_EQUAL(0, (int)invVars.count(var));
invVars.insert(var);
}
cvi->release_ref();
std::set<iface::cellml_api::CellMLVariable*>::iterator invVarsI;
// Time is included in the count as well.
CPPUNIT_ASSERT_EQUAL(4, (int)invVars.size());
CPPUNIT_ASSERT_EQUAL(1, (int)invVars.count(vglcC));
CPPUNIT_ASSERT_EQUAL(1, (int)invVars.count(vdelta_Glc_C_rxn1));
CPPUNIT_ASSERT_EQUAL(1, (int)invVars.count(vdelta_Glc_C_rxn2));
for (invVarsI = invVars.begin(); invVarsI != invVars.end(); invVarsI++)
(*invVarsI)->release_ref();
cvi = mr->iterateBoundVariables();
var = cvi->nextVariable();
CPPUNIT_ASSERT(var != vglcC);
var->release_ref();
CPPUNIT_ASSERT(!cvi->nextVariable().getPointer());
cvi->release_ref();
CPPUNIT_ASSERT_EQUAL(1, (int)mr->getDiffDegree(vglcC));
CPPUNIT_ASSERT(!mr->involvesExternalCode());
mr->release_ref();
expr->release_ref();
vglcC->release_ref();
vdelta_Glc_C_rxn1->release_ref();
vdelta_Glc_C_rxn2->release_ref();
gts->release_ref();
gp->release_ref();
glcC->release_ref();
as->release_ref();
cu->release_ref();
cev->release_ref();
mt->release_ref();
m->release_ref();
}
std::wstring
CellMLModelDefinition::getModelAsCCode(void* _model,void* _annotations)
{
iface::cellml_api::Model* model = static_cast<iface::cellml_api::Model*>(_model);
iface::cellml_services::AnnotationSet* as = static_cast<iface::cellml_services::AnnotationSet*>(_annotations);
std::wstring code;
RETURN_INTO_OBJREF(cgb,iface::cellml_services::CodeGeneratorBootstrap,
CreateCodeGeneratorBootstrap());
RETURN_INTO_OBJREF(cg,iface::cellml_services::CodeGenerator,
cgb->createCodeGenerator());
#if defined (CUSTOM_CODE_GENERATION)
RETURN_INTO_OBJREF(ccg, iface::cellml_services::CustomGenerator,
cg->createCustomGenerator(model));
RETURN_INTO_OBJREF(cti, iface::cellml_services::ComputationTargetIterator,
ccg->iterateTargets());
while (true)
{
RETURN_INTO_OBJREF(ct, iface::cellml_services::ComputationTarget,
cti->nextComputationTarget());
if (ct == NULL) break;
RETURN_INTO_WSTRING(flag,as->getStringAnnotation(ct->variable(),L"flag"));
if ((flag == L"WANTED") || (ct->degree() > 0))
{
ccg->requestComputation(ct);
}
else if (flag == L"KNOWN")
{
ccg->markAsKnown(ct);
}
}
#endif
/* The trunk MaLaES has been updated since the 1.5 release, so define a
* "custom" MaLaES here
*/
RETURN_INTO_OBJREF(mbs,iface::cellml_services::MaLaESBootstrap,
CreateMaLaESBootstrap());
RETURN_INTO_OBJREF(mt,iface::cellml_services::MaLaESTransform,
mbs->compileTransformer(
L"opengroup: (\r\n"
L"closegroup: )\r\n"
L"abs: #prec[H]fabs(#expr1)\r\n"
L"and: #prec[20]#exprs[&&]\r\n"
L"arccos: #prec[H]acos(#expr1)\r\n"
L"arccosh: #prec[H]acosh(#expr1)\r\n"
L"arccot: #prec[1000(900)]atan(1.0/#expr1)\r\n"
L"arccoth: #prec[1000(900)]atanh(1.0/#expr1)\r\n"
L"arccsc: #prec[1000(900)]asin(1/#expr1)\r\n"
L"arccsch: #prec[1000(900)]asinh(1/#expr1)\r\n"
L"arcsec: #prec[1000(900)]acos(1/#expr1)\r\n"
L"arcsech: #prec[1000(900)]acosh(1/#expr1)\r\n"
L"arcsin: #prec[H]asin(#expr1)\r\n"
L"arcsinh: #prec[H]asinh(#expr1)\r\n"
L"arctan: #prec[H]atan(#expr1)\r\n"
L"arctanh: #prec[H]atanh(#expr1)\r\n"
L"ceiling: #prec[H]ceil(#expr1)\r\n"
L"cos: #prec[H]cos(#expr1)\r\n"
L"cosh: #prec[H]cosh(#expr1)\r\n"
L"cot: #prec[900(0)]1.0/tan(#expr1)\r\n"
L"coth: #prec[900(0)]1.0/tanh(#expr1)\r\n"
L"csc: #prec[900(0)]1.0/sin(#expr1)\r\n"
L"csch: #prec[900(0)]1.0/sinh(#expr1)\r\n"
L"diff: #lookupDiffVariable\r\n"
L"divide: #prec[900]#expr1/#expr2\r\n"
L"eq: #prec[30]#exprs[==]\r\n"
L"exp: #prec[H]exp(#expr1)\r\n"
L"factorial: #prec[H]factorial(#expr1)\r\n"
L"factorof: #prec[30(900)]#expr1 % #expr2 == 0\r\n"
L"floor: #prec[H]floor(#expr1)\r\n"
L"gcd: #prec[H]gcd_multi(#count, #exprs[, ])\r\n"
L"geq: #prec[30]#exprs[>=]\r\n"
L"gt: #prec[30]#exprs[>]\r\n"
L"implies: #prec[10(950)] !#expr1 || #expr2\r\n"
L"int: #prec[H]defint(func#unique1, BOUND, CONSTANTS, RATES, VARIABLES, "
L"#bvarIndex, pret)#supplement double func#unique1(double* BOUND, "
L"double* CONSTANTS, double* RATES, double* VARIABLES, int* pret) { return #expr1; }\r\n"
L"lcm: #prec[H]lcm_multi(#count, #exprs[, ])\r\n"
L"leq: #prec[30]#exprs[<=]\r\n"
L"ln: #prec[H]log(#expr1)\r\n"
L"log: #prec[H]arbitrary_log(#expr1, #logbase)\r\n"
L"lt: #prec[30]#exprs[<]\r\n"
L"max: #prec[H]multi_max(#count, #exprs[, ])\r\n"
L"min: #prec[H]multi_min(#count, #exprs[, ])\r\n"
L"minus: #prec[500]#expr1 - #expr2\r\n"
L"neq: #prec[30]#expr1 != #expr2\r\n"
L"not: #prec[950]!#expr1\r\n"
L"or: #prec[10]#exprs[||]\r\n"
L"plus: #prec[500]#exprs[+]\r\n"
L"power: #prec[H]pow(#expr1, #expr2)\r\n"
L"quotient: #prec[1000(0)] (double)(((int)#expr2) == 0 ? #expr1 / 0.0 : (int)(#expr1) / (int)(#expr2))\r\n"
L"rem: #prec[1000(0)] (double)(((int)#expr2) == 0 ? (#expr1) / 0.0 : (int)(#expr1) % (int)(#expr2))\r\n"
L"root: #prec[1000(900)] pow(#expr1, 1.0 / #degree)\r\n"
L"sec: #prec[900(0)]1.0 / cos(#expr1)\r\n"
L"sech: #prec[900(0)]1.0 / cosh(#expr1)\r\n"
L"sin: #prec[H] sin(#expr1)\r\n"
L"sinh: #prec[H] sinh(#expr1)\r\n"
L"tan: #prec[H] tan(#expr1)\r\n"
L"tanh: #prec[H] tanh(#expr1)\r\n"
L"times: #prec[900] #exprs[*]\r\n"
L"unary_minus: #prec[950]- #expr1\r\n"
L"units_conversion: #prec[500(900)]#expr1*#expr2 + #expr3\r\n"
L"units_conversion_factor: #prec[900]#expr1*#expr2\r\n"
L"units_conversion_offset: #prec[500]#expr1+#expr2\r\n"
L"xor: #prec[25(30)] (#expr1 != 0) ^ (#expr2 != 0)\r\n"
L"piecewise_first_case: #prec[1000(5)](#expr1 ? #expr2 : \r\n"
L"piecewise_extra_case: #prec[1000(5)]#expr1 ? #expr2 : \r\n"
L"piecewise_otherwise: #prec[1000(5)]#expr1)\r\n"
L"piecewise_no_otherwise: #prec[1000(5)]0.0/0.0)\r\n"
L"eulergamma: #prec[999]0.577215664901533\r\n"
L"exponentiale: #prec[999]2.71828182845905\r\n"
L"false: #prec[999]0.0\r\n"
L"infinity: #prec[900]1.0/0.0\r\n"
L"notanumber: #prec[999]0.0/0.0\r\n"
L"pi: #prec[999] 3.14159265358979\r\n"
L"true: #prec[999]1.0\r\n"));
/* now can use the standard transformation?
cg->transform(mt);
*/
try
{
#if defined (CUSTOM_CODE_GENERATION)
RETURN_INTO_OBJREF(cci,iface::cellml_services::CustomCodeInformation,ccg->generateCode());
printf("Constraint level = ");
switch (cci->constraintLevel())
{
case iface::cellml_services::UNDERCONSTRAINED:
printf("UNDERCONSTRAINED\n");
break;
case iface::cellml_services::UNSUITABLY_CONSTRAINED:
printf("UNSUITABLY_CONSTRAINED\n");
break;
case iface::cellml_services::OVERCONSTRAINED:
printf("OVERCONSTRAINED\n");
break;
case iface::cellml_services::CORRECTLY_CONSTRAINED:
printf("CORRECTLY_CONSTRAINED\n");
break;
default:
printf("Unkown value\n");
}
printf("Index count: %u\n", cci->indexCount());
cti = already_AddRefd<iface::cellml_services::ComputationTargetIterator>(cci->iterateTargets());
while (true)
{
RETURN_INTO_OBJREF(ct, iface::cellml_services::ComputationTarget,
cti->nextComputationTarget());
if (ct == NULL)
break;
RETURN_INTO_OBJREF(cv, iface::cellml_api::CellMLVariable, ct->variable());
RETURN_INTO_WSTRING(compname, cv->componentName());
RETURN_INTO_WSTRING(varname, cv->name());
printf("* Computation target %S/%S:%u:\n", compname.c_str(), varname.c_str(),
ct->degree());
printf(" => Type = ");
switch (ct->type())
{
case iface::cellml_services::VARIABLE_OF_INTEGRATION:
printf("VARIABLE_OF_INTEGRATION - was marked as independent.\n");
break;
case iface::cellml_services::CONSTANT:
printf("CONSTANT - this should not happen!\n");
break;
case iface::cellml_services::STATE_VARIABLE:
printf("STATE_VARIABLE - was requested, and is available.\n");
break;
case iface::cellml_services::ALGEBRAIC:
printf("ALGEBRAIC - is used as an intermediate.\n");
break;
case iface::cellml_services::FLOATING:
printf("FLOATING - unused and not requested.\n");
break;
case iface::cellml_services::LOCALLY_BOUND:
printf("LOCALLY_BOUND - locally bound in expressions only.\n");
break;
case iface::cellml_services::PSEUDOSTATE_VARIABLE:
printf("PSEUDOSTATE_VARIABLE - target was requested, but could "
"not be computed from the independent variables and model.\n");
break;
default:
printf("Unknown type!\n");
}
RETURN_INTO_WSTRING(targname, ct->name());
printf(" => Name = %S\n", targname.c_str());
printf(" => Index = %u\n", ct->assignedIndex());
}
// To do: Print output from cci->iterateTargets();
RETURN_INTO_WSTRING(functionsString, cci->functionsString());
printf("Functions: %S\n", functionsString.c_str());
RETURN_INTO_WSTRING(codeS, cci->generatedCode());
printf("Code: %S\n", codeS.c_str());
#else // CUSTOM_CODE_GENERATION
// annotate the source variables in the model with the code-names based on existing annotations
RETURN_INTO_OBJREF(cvbs,iface::cellml_services::CeVASBootstrap,CreateCeVASBootstrap());
RETURN_INTO_OBJREF(cevas,iface::cellml_services::CeVAS,cvbs->createCeVASForModel(model));
for (unsigned int i=0;i<cevas->length();i++)
{
RETURN_INTO_OBJREF(cvs,iface::cellml_services::ConnectedVariableSet,cevas->getVariableSet(i));
RETURN_INTO_OBJREF(sv,iface::cellml_api::CellMLVariable,cvs->sourceVariable());
RETURN_INTO_WSTRING(array,as->getStringAnnotation(sv,L"array"));
RETURN_INTO_WSTRING(index,as->getStringAnnotation(sv,L"array_index"));
if (!array.empty() && !index.empty())
{
std::wstring ename = array;
ename += L"[";
ename += index;
ename += L"]";
as->setStringAnnotation(sv,L"expression",ename.c_str());
if (array == L"OC_STATE")
{
ename = std::wstring(L"OC_RATE");
ename += L"[";
ename += index;
ename += L"]";
as->setStringAnnotation(sv,L"expression_d1",ename.c_str());
}
}
}
cg->useCeVAS(cevas);
cg->useAnnoSet(as);
RETURN_INTO_OBJREF(cci,iface::cellml_services::CodeInformation,cg->generateCode(model));
wchar_t* m = cci->errorMessage();
if (!wcscmp(m,L""))
{
std::cout << "whoo hoo!" << std::endl;
iface::cellml_services::ModelConstraintLevel mcl = cci->constraintLevel();
if (mcl == iface::cellml_services::UNDERCONSTRAINED)
{
std::cerr << "Model is underconstrained" << std::endl;
}
else if (mcl == iface::cellml_services::OVERCONSTRAINED)
{
std::cerr << "Model is overconstrained" << std::endl;
}
else if (mcl == iface::cellml_services::UNSUITABLY_CONSTRAINED)
{
std::cerr << "Model is unsuitably constrained" << std::endl;
}
else
{
std::cout << "Model is correctly constrained" << std::endl;
// create the code in the format we know how to handle
code += L"#include <math.h>\n";
code += L"#include <stdio.h>\n";
/* required functions */
code += L"extern double fabs(double x);\n";
code += L"extern double acos(double x);\n";
code += L"extern double acosh(double x);\n";
code += L"extern double atan(double x);\n";
code += L"extern double atanh(double x);\n";
code += L"extern double asin(double x);\n";
code += L"extern double asinh(double x);\n";
code += L"extern double acos(double x);\n";
code += L"extern double acosh(double x);\n";
code += L"extern double asin(double x);\n";
code += L"extern double asinh(double x);\n";
code += L"extern double atan(double x);\n";
code += L"extern double atanh(double x);\n";
code += L"extern double ceil(double x);\n";
code += L"extern double cos(double x);\n";
code += L"extern double cosh(double x);\n";
code += L"extern double tan(double x);\n";
code += L"extern double tanh(double x);\n";
code += L"extern double sin(double x);\n";
code += L"extern double sinh(double x);\n";
code += L"extern double exp(double x);\n";
code += L"extern double floor(double x);\n";
code += L"extern double pow(double x, double y);\n";
code += L"extern double factorial(double x);\n";
code += L"extern double log(double x);\n";
code += L"extern double arbitrary_log(double x, double base);\n";
code += L"extern double gcd_pair(double a, double b);\n";
code += L"extern double lcm_pair(double a, double b);\n";
code += L"extern double gcd_multi(unsigned int size, ...);\n";
code += L"extern double lcm_multi(unsigned int size, ...);\n";
code += L"extern double multi_min(unsigned int size, ...);\n";
code += L"extern double multi_max(unsigned int size, ...);\n";
code += L"extern void NR_MINIMISE(double(*func)"
L"(double VOI, double *C, double *R, double *S, double *A),"
L"double VOI, double *C, double *R, double *S, double *A, "
L"double *V);\n";
wchar_t* frag = cci->functionsString();
code += frag;
free(frag);
nBound = 1;
nRates = cci->rateIndexCount();
nAlgebraic = cci->algebraicIndexCount();
nConstants = cci->constantIndexCount();
code += L"\n\nvoid OC_CellML_RHS_routine(double VOI, double* OC_STATE, double* OC_RATE, double* OC_WANTED, double* OC_KNOWN)\n{\n\n";
code += L"double DUMMY_ASSIGNMENT;\n";
code += L"double CONSTANTS[";
code += formatNumber(nConstants);
code += L"], ALGEBRAIC[";
code += formatNumber(nAlgebraic);
code += L"];\n\n";
// start the model code...
/* https://svn.physiomeproject.org/svn/physiome/CellML_DOM_API/trunk/interfaces/CCGS.idl for full description */
/* initConsts - all variables which aren't state variables but have
* an initial_value attribute, and any variables & rates
* which follow.
*/
frag = cci->initConstsString();
//code += L"void SetupFixedConstants(double* CONSTANTS,double* RATES,"
// L"double* STATES)\n{\n";
code += frag;
//code += L"}\n";
free(frag);
/* rates - All rates which are not static.
*/
frag = cci->ratesString();
//code += L"void ComputeRates(double VOI,double* STATES,double* RATES,"
// L"double* CONSTANTS,double* ALGEBRAIC)\n{\n";
code += frag;
//code += L"}\n";
free(frag);
/* variables - All variables not computed by initConsts or rates
* (i.e., these are not required for the integration of the model and
* thus only need to be called for output or presentation or similar
* purposes)
*/
frag = cci->variablesString();
//code += L"void EvaluateVariables(double VOI,double* CONSTANTS,"
// L"double* RATES, double* STATES, double* ALGEBRAIC)\n{\n";
code += frag;
//code += L"}\n";
free(frag);
// and now clear out initialisation of state variables and known variables.
clearCodeAssignments(code,L"OC_STATE",mStateCounter);
clearCodeAssignments(code,L"OC_KNOWN",mParameterCounter);
// close the subroutine
code += L"\n\n}//OC_CellML_RHS_routine()\n\n;";
}
}
else
{
std::wcerr << "Error generating code: " << m << std::endl;
}
free(m);
#endif // CUSTOM_CODE_GENERATION
}
catch (...)
{
std::wcerr << L"Error generating the code information for model"
<< std::endl;
}
return code;
}
int CellmlModelDefinition::instantiateCellmlApiObjects()
{
try
{
// create an annotation set to manage our variable usages
ObjRef<iface::cellml_services::AnnotationToolService> ats = CreateAnnotationToolService();
ObjRef<iface::cellml_services::AnnotationSet> as = ats->createAnnotationSet();
mCapi->annotations = as;
// mapping the connections between variables is a very expensive operation, so we want to
// only do it once and keep hold of the mapping (tracker item 3294)
ObjRef<iface::cellml_services::CeVASBootstrap> cvbs = CreateCeVASBootstrap();
ObjRef<iface::cellml_services::CeVAS> cevas = cvbs->createCeVASForModel(mCapi->model);
std::wstring msg = cevas->modelError();
if (msg != L"")
{
std::cerr << "loadModel: Error creating CellML Variable Association Service: "
<< ws2s(msg) << std::endl;
return -2;
}
mCapi->cevas = cevas;
// now check we can generate code and grab hold of the initial code information
ObjRef<iface::cellml_services::CodeGeneratorBootstrap> cgb = CreateCodeGeneratorBootstrap();
ObjRef<iface::cellml_services::CodeGenerator> cg = cgb->createCodeGenerator();
try
{
cg->useCeVAS(cevas);
ObjRef<iface::cellml_services::CodeInformation> cci = cg->generateCode(mCapi->model);
msg = cci->errorMessage();
if (msg != L"")
{
std::cerr << "CellmlModelDefintion::loadModel: Error generating code: "
<< ws2s(msg) << std::endl;
return -4;
}
// TODO: we are only interested in models we can work with?
if (cci->constraintLevel() != iface::cellml_services::CORRECTLY_CONSTRAINED)
{
std::cerr << "CellmlModelDefintion::loadModel: Model is not correctly constrained: "
<< std::endl;
return -5;
}
mCapi->codeInformation = cci;
// always flag all state variables and the variable of integration
ObjRef<iface::cellml_services::ComputationTargetIterator> cti = cci->iterateTargets();
while (true)
{
ObjRef<iface::cellml_services::ComputationTarget> ct = cti->nextComputationTarget();
if (ct == NULL) break;
if (ct->degree() > 0) break; // only want to initialise the base variables not the differential
ObjRef<iface::cellml_api::CellMLVariable> v(ct->variable());
if (ct->type() == iface::cellml_services::STATE_VARIABLE)
{
mVariableTypes[getVariableUniqueId(v)] = csim::StateType;
mVariableIndices[getVariableUniqueId(v)][csim::StateType] = mStateCounter;
mStateCounter++;
}
else if (ct->type() == iface::cellml_services::VARIABLE_OF_INTEGRATION)
{
mVariableTypes[getVariableUniqueId(v)] = csim::IndependentType;
mNumberOfIndependentVariables++;
}
else
{
// need to initialise the variable type
mVariableTypes[getVariableUniqueId(v)] = csim::UndefinedType;
}
}
}
catch (...)
{
std::cerr << "loadModel: Error generating the code information for the model" << std::endl;
return -3;
}
// if we get to here, everything worked.
mModelLoaded = true;
}
catch (...)
{
std::wcerr << L"Error instantiating CellML API objects." << std::endl;
return -1;
}
return csim::CSIM_OK;
}
