9367271584

Committed 04 Jun 2024 12:41PM UTC coverage: 70.119% (+0.02%) from 70.102%

Build # 9367271584

Build Type

push

github

Committed by

metelkin

Commit Message

do not allow empty math and arguments for defineFunction

Run Details

1741 of 2585 branches covered (67.35%)

Branch coverage included in aggregate %.

7 of 16 new or added lines in 2 files covered. (43.75%)

6 existing lines in 1 file now uncovered.

2931 of 4078 relevant lines covered (71.87%)

75.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.23

/src/module-system/sbml-parse.js

const _toMathExpr = require('./to-math-expr');
const { xml2js } = require('xml-js');
const { Unit } = require('../core/unit');
const legalUnits = require('../legal-sbml-units');
const HetaLevelError = require('../heta-level-error');

/**
 * Transforms text content of SBML file to Q-array.
 * 
 * @param {string} fileContent SBML file content.
 * @returns {array} Parsed content in Q-array format.
 */
function SBMLParse(fileText){
  let JSBML = xml2js(fileText, { compact: false });
  
  return jsbmlToQArr(JSBML);
}

/*
  Converst of JSON image of SBML to Heta array
*/
function jsbmlToQArr(JSBML){
  let qArr = [];
  eventCounter = 0; // reset event counter

  let sbml = JSBML.elements // <file>
    .find((x) => x.name === 'sbml'); // <sbml>

  let model = sbml.elements
    .find((x) => x.name === 'model'); // <model>

  // unit definition
  let unitDict = {};
  model.elements
    .filter((x) => x.name === 'listOfUnitDefinitions')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'unitDefinition')
    .forEach((x) => {
      unitDict[x.attributes.id] = unitDefinitionToUnits(x);
    });

  // algebraicRules
  
  model.elements
    .filter((x) => x.name === 'listOfFunctionDefinitions')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'functionDefinition')
    .forEach((x) => {
      let q = functionDefinitionToQ(x);
      qArr.push(q);
    });

  // species types, for IRT
  model.elements
    .filter((x) => x.name ==='listOfSpeciesTypes')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'speciesType')
    .forEach((x) => {
      let q = speciesTypeToQ(x);
      qArr.push(q);
    });

  // compartments
  let zeroSpatialDimensions = [];
  model.elements
    .filter((x) => x.name === 'listOfCompartments')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'compartment')
    .forEach((x) => {
      // collect compartments with zero dimention
      let isZero = x.attributes?.spatialDimensions === '0';
      if (isZero) {
        zeroSpatialDimensions.push(x.attributes?.id);
        // set zero initial size
        x.attributes = Object.assign({}, x.attributes, {size: '0'});
      }

      let q = compartmentToQ(x, unitDict);
      qArr.push(q);
    });

  // species
  model.elements
    .filter((x) => x.name === 'listOfSpecies')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'species')
    .forEach((x) => {
      let q = speciesToQ(x, zeroSpatialDimensions, qArr, unitDict);
      qArr.push(q);
    });

  // reactions
  model.elements
    .filter((x) => x.name === 'listOfReactions')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'reaction')
    .forEach((x) => {
      let qArr_add = reactionToQ(x);
      qArr = qArr.concat(qArr_add);
    });

  // parameters
  model.elements
    .filter((x) => x.name === 'listOfParameters')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'parameter')
    .forEach((x) => {
      let q = parameterToQ(x, unitDict);
      qArr.push(q);
    });

  // initialAssignments
  model.elements
    .filter((x) => x.name === 'listOfInitialAssignments')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'initialAssignment')
    .forEach((x) => {
      let q = initialAssignmentToQ(x);
      qArr.push(q);
    });

  // assignmentRules
  model.elements
    .filter((x) => x.name === 'listOfRules')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'assignmentRule')
    .forEach((x) => {
      let q = assignmentRuleToQ(x);
      qArr.push(q);
    });

  // algebraicRules
  let algebraicRules = model.elements
    .filter((x) => x.name === 'listOfRules')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'algebraicRule');
  if (algebraicRules.length !== 0) {
    throw new HetaLevelError('"algebraicRule" from SBML module is not supported.');
  }

  // rateRules
  model.elements
    .filter((x) => x.name === 'listOfRules')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'rateRule')
    .forEach((x) => {
      let qArr_add = rateRuleToQ(x);
      qArr = qArr.concat(qArr_add);
    });

  // events
  model.elements
    .filter((x) => x.name === 'listOfEvents')
    .map((x) => x.elements)
    .flat(1)
    .filter((x) => x.name === 'event')
    .forEach((x) => {
      let qs = eventToQ(x);
      qArr = qArr.concat(qs);
    });

  return qArr;
}

/*
  transform SBML-like unit definition to Heta-like unit array
*/
function unitDefinitionToUnits(x){
  let units = x.elements
    .filter((x) => x.name === 'listOfUnits')[0]
    .elements
    .map((element) => {
      let { kind, multiplier, scale, exponent } = element.attributes;
      return {
        kind: kind,
        multiplier: (multiplier || 1) * 10**(scale || 0),
        exponent: parseInt(exponent) || 1
      };
    });

  return Unit.fromQ(units);
}


/*
  transform SBML-like function definition to Heta-like unit array
*/
function functionDefinitionToQ(x) {

  let q = {
    action: 'defineFunction',
    id: x.attributes.id
  };

  let mathElement = x.elements?.find((y) => y.name === 'math');
  let lambdaElement = mathElement?.elements?.find((y) => y.name === 'lambda');

  if (!mathElement || !lambdaElement ) {
    throw new HetaLevelError(`Heta does not support empty <math> or <lambda> "${q.id}" elements in FunctionDefinition,`);
  }

  // get argument ids
  q.args = lambdaElement.elements
    ?.filter((y) => y.name === 'bvar')
    .map((y) => y.elements && y.elements.find((z) => z.name === 'ci'))
    .map((y) => y.elements && y.elements.find((z) => z.type === 'text'))
    .map((y) => y.text.trim());

  // get expression
  let notBvarElement = lambdaElement.elements
    ?.find((y) => y.name !== 'bvar');
  q.math = _toMathExpr(notBvarElement);


  return q;
}

/*
  Converts common properties to Heta Object
*/
function baseToQ(x){
  let q = {
    id: x.attributes?.id,
    title: x.attributes?.name,
    aux: {}
  };
  // set metaid
  let metaid = x.attributes?.metaid;
  if (metaid !== undefined) q.aux.metaid = metaid;
  // set sboTerm
  let sboTerm = x.attributes?.sboTerm;
  if (sboTerm !== undefined) q.aux.sboTerm = sboTerm;
  // take only first notes
  let notes = x.elements?.find((y) => y.name === 'notes');
  if (notes) q.notes = _toMarkdown(notes.elements);
  // annotation
  let annotation = x.elements?.find((y) => y.name === 'annotation');
  if (annotation) q.aux.annotation = _toAux(annotation.elements);

  return q;
}

function _toMarkdown(elements = []){
  let text = elements.map((x) => {
    if (x.type === 'text') {
      return x.text.replace(/\r*\n/g, '');
    } else {
      switch (x.name) {
      case 'body':
      case 'div':
      case 'p':
        return _toMarkdown(x.elements) + '\n\n';
        break;
      case 'b':
      case 'strong':
        return '**' + _toMarkdown(x.elements) + '**';
        break;
      case 'i':
        return '_' +_toMarkdown(x.elements) + '_';
        break;
      case 'ul': {
        let list = x.elements.map((y) => '  * ' +_toMarkdown(y.elements))
          .join('\n');
        return list;
        break;
      }
      case 'ol': {
        let list = x.elements.map((y) => '  1. ' +_toMarkdown(y.elements))
          .join('\n');
        return list;
        break;
      }
      case 'a': {
        let href = x.attributes?.href;
        let title = x.attributes?.title;
        return '[' + _toMarkdown(x.elements) + '](' + href + ')';
        break;
      }
      case 'h1':
        return '# ' + _toMarkdown(x.elements) + '\n\n';
        break;
      case 'h2':
        return '## ' + _toMarkdown(x.elements) + '\n\n';
        break;
      case 'h3':
        return '### ' + _toMarkdown(x.elements) + '\n\n';
        break;
      case 'h4':
        return '#### ' + _toMarkdown(x.elements) + '\n\n';
        break;
      case 'h5':
        return '##### ' + _toMarkdown(x.elements) + '\n\n';
        break;
      case 'h6':
        return '###### ' + _toMarkdown(x.elements) + '\n\n';
        break;
      default:
        return _toMarkdown(x.elements);
      }
    }
  }).join('');

  return text;
}

// TODO: use the same result as in SBMLViewer
function _toAux(elements){
  return elements;
}

function speciesTypeToQ(x){
  let q = baseToQ(x);
  q.class = 'Component';
  
  return q;
}

function compartmentToQ(x, unitDict = {}){
  let q = baseToQ(x);

  q.class = 'Compartment';
  q.boundary = x.attributes?.constant !== 'false';
  let num = x.attributes?.size;
  
  if (num !== undefined) {
    q.assignments = { start_: SBMLValueToNumber(num) };
  }
  // units
  let unitId = x.attributes?.units;
  if (typeof unitId !== 'undefined') {
    let legalUnitIndex = legalUnits.indexOf(unitId); //
    if (legalUnitIndex !== -1) { // if id in legal unit list
      q.units = Unit.fromQ([{ kind: unitId }]);
    } else if (unitDict[unitId] !== undefined){
      q.units = unitDict[unitId].simplify('dimensionless');
    } else {
      q.units = Unit.fromQ([{ kind: unitId }]);
      // the alternative solution is to throw undeclared units
      //throw new HetaLevelError(`No unitDeclaration "${unitId}" used for compartment "${q.id}"`);
    }
  }

  // compartmentType
  let compartmentType = x.attributes?.compartmentType;
  if (compartmentType !== undefined) {
    q.tags = [compartmentType];
  }

  return q;
}

function speciesToQ(x, zeroSpatialDimensions = [], qArr = [], unitDict = {}){
  let q = baseToQ(x);

  q.class = 'Species';
  q.boundary = x.attributes?.constant === 'true' 
    || x.attributes?.boundaryCondition === 'true';
  q.compartment = x.attributes?.compartment;
  q.isAmount = x.attributes?.hasOnlySubstanceUnits === 'true'
    || zeroSpatialDimensions.indexOf(q.compartment) >= 0;
  let concentration = x.attributes?.initialConcentration;
  let amount = x.attributes?.initialAmount;
  if (concentration !== undefined && !q.isAmount) {
    q.assignments = { start_: SBMLValueToNumber(concentration) };
  } else if (concentration !== undefined && q.isAmount) {
    q.assignments = { start_: SBMLValueToNumber(concentration) + '*' + q.compartment };
  } else if (amount !== undefined && !q.isAmount) {
    q.assignments = { start_: SBMLValueToNumber(amount) + '/' + q.compartment };
  } else if (amount !== undefined && q.isAmount) {
    q.assignments = { start_: SBMLValueToNumber(amount) };
  }
  // speciesType
  let speciesType = x.attributes?.speciesType;
  if (speciesType !== undefined) q.tags = [speciesType];

  // units
  let substanceUnitId = x.attributes?.substanceUnits;
  if (typeof substanceUnitId !== 'undefined') {
    // find compartment units
    let compartmentComponent = qArr.find((component) => component.id === q.compartment);
    if (!compartmentComponent)
      throw new HetaLevelError(`Compartment "${q.compartment}" for "${q.id}" is not found in SBML`);
    let compartmentUnits = compartmentComponent.units;

    // set species units
    let legalUnitIndex = legalUnits.indexOf(substanceUnitId);
    if (legalUnitIndex !== -1) { // if id in legal unit list
      let amountUnits = Unit.fromQ([{ kind: substanceUnitId }]);
      if (q.isAmount) {
        q.units = amountUnits;
      } else if (compartmentUnits !== undefined) {
        q.units = amountUnits
          .divide(compartmentUnits)
          .simplify();
      }
    } else if (unitDict[substanceUnitId] !== undefined) {
      let amountUnits = unitDict[substanceUnitId];
      // set amount or concentration units
      if (q.isAmount) {
        q.units = amountUnits
          .simplify();
      } else if (compartmentUnits !== undefined) {
        q.units = amountUnits
          .divide(compartmentUnits)
          .simplify();
      }
    } else {
      let amountUnits = Unit.fromQ([{ kind: substanceUnitId }]);
      if (q.isAmount) {
        q.units = amountUnits;
      } else if (compartmentUnits !== undefined) {
        q.units = amountUnits
          .divide(compartmentUnits)
          .simplify();
      }
      // alternative solution is to throw error for undeclared "substance"
      // throw new HetaLevelError(`No unitDeclaration "${substanceUnitId}" used for species "${q.id}"`);
    }
  }

  return q;
}

function reactionToQ(x){
  let qArr = [];
  let localConstTranslate = [];
  let q = baseToQ(x);

  q.class = 'Reaction';

  let kineticLaw = x.elements?.find((y) => y.name === 'kineticLaw');
  
  // local parameters
  let listOfParameters = kineticLaw?.elements?.find((y) => y.name === 'listOfParameters');
  if (listOfParameters) {
    let parameters = listOfParameters.elements
      .filter((y) => y.name = 'parameter');
    parameters.forEach((y) => {
      let id = y.attributes?.id;
      let newId = id + '__' + q.id + '_local';
      // set translator
      localConstTranslate.push({id, newId});
      // add component
      qArr.push({
        class: 'Const',
        id: newId,
        num: Number.parseFloat(y.attributes?.value)
      });
    });
  }
  // math
  let math = kineticLaw?.elements?.find((y) => y.name === 'math');
  if (math) {
    let expr = _toMathExpr(math);
    localConstTranslate.forEach((y) => {
      let regexp = new RegExp(`\\b${y.id}\\b`, 'g');
      expr = expr.replace(regexp, y.newId);
    });
    q.assignments = { ode_: expr };
  }

  // check if reversible
  q.reversible = x.attributes?.reversible !== 'false' ;
  
  // check if fast
  let fast = x.attributes?.fast === 'true' ;
  // q.aux.fast = fast;
  if (fast) {
    throw new HetaLevelError(`"fast" reactions "${q.id}" is not supported in SBML module.`);
  }

  // products
  let products = x.elements?.find((y) => y.name === 'listOfProducts');
  if (products?.elements) {
    var actors0 = products.elements
      .filter((y) => y.name === 'speciesReference')
      .map((y) => {
        // check stoichiometry as an expression
        let stoichiometryExpr = (y.elements || [])
          .filter((z) => z.name === 'stoichiometryMath');
        if (stoichiometryExpr.length > 0)
          throw new HetaLevelError('"stoichiometryMath" from SBML module is not supported.');

        // get constant stoichiometry
        let stoichiometry = y.attributes?.stoichiometry || '1';
        return {
          target: y.attributes?.species,
          stoichiometry: Number.parseFloat(stoichiometry)
        };
      });
  } else {
    actors0 = [];
  }

  // reactants
  let reactants = x.elements?.find((y) => y.name === 'listOfReactants');
  if (reactants?.elements) {
    var actors1 = reactants.elements
      .filter((y) => y.name === 'speciesReference')
      .map((y) => {
        // check stoichiometry as an expression
        let stoichiometryExpr = (y.elements || [])
          .filter((z) => z.name === 'stoichiometryMath');
        if (stoichiometryExpr.length > 0)
          throw new HetaLevelError('"stoichiometryMath" from SBML module is not supported.');

        // get constant stoichiometry
        let stoichiometry = y.attributes?.stoichiometry || '1';
        return {
          target: y.attributes?.species,
          stoichiometry: (-1) * Number.parseFloat(stoichiometry)
        };
      });
  } else {
    actors1 = [];
  }

  // modifiers
  let modifiers1 = (x.elements?.find((y) => y.name === 'listOfModifiers')?.elements || [])
    .filter((y) => y.name === 'modifierSpeciesReference')
    .map((y) => {
      return { target: y.attributes?.species };
    });

  q.actors = actors0.concat(actors1);
  q.modifiers = modifiers1;

  // add reaction q
  qArr.push(q);
  return qArr;
}

function parameterToQ(x, unitDict = {}){
  let q = baseToQ(x);

  let isConstant = x.attributes?.constant === 'true';
  let num = x.attributes?.value;
  if (isConstant) {
    q.class = 'Const';
    if (num !== undefined) {
      q.num = SBMLValueToNumber(num);
    }
  } else {
    q.class = 'Record';
    if (num !== undefined) {
      q.assignments = { start_: SBMLValueToNumber(num) };
    }
  }

  // units
  let unitId = x.attributes?.units;
  if (typeof unitId !== 'undefined') {
    let legalUnitIndex = legalUnits.indexOf(unitId); //
    if (legalUnitIndex !== -1) { // if id in legal unit list
      q.units = Unit.fromQ([{ kind: unitId }]);
    } else if (unitDict[unitId] !== undefined) { // if id in unitDefinitions
      // I removed simplify here to support pretty units in IRT
      q.units = unitDict[unitId]; //.simplify(); 
    } else {
      q.units = Unit.fromQ([{ kind: unitId }]);
      // alternative solution is to throw undeclared "unit"
      //throw new HetaLevelError(`No unitDeclaration "${unitId}" as required for parameter "${q.id}"`);
    }
  }

  return q;
}

function initialAssignmentToQ(x){
  let q = {
    id: x.attributes?.symbol,
  };

  let math = x.elements?.find((y) => y.name === 'math');
  if (math !== undefined) {
    q.assignments = {start_: _toMathExpr(math)};
  }

  return q;
}

function assignmentRuleToQ(x){
  let q = {
    id: x.attributes?.variable
  };

  let math = x.elements?.find((y) => y.name === 'math');
  if (math !== undefined) {
    q.assignments = { ode_: _toMathExpr(math) };
  }

  return q;
}

function rateRuleToQ(x){
  let q0 = baseToQ(x);

  let target = x.attributes?.variable;
  q0.id = target + '_proc';
  q0.class = 'Process';
  q0.actors = [{
    stoichiometry: 1,
    target: target
  }];

  let math = x.elements?.find((y) => y.name === 'math');
  if (math !== undefined) {
    q0.assignments = { ode_: _toMathExpr(math) };
  }

  // remove boundary for Species, because Heta does not change boundary species, but SBML does.
  let q1 = { id: target, boundary: false };

  return [q0, q1];
}

let eventCounter = 0;
function eventToQ(x){
  let qArr = [];

  let switcher = baseToQ(x);
  switcher.class = 'DSwitcher';
  if (switcher.id === undefined) switcher.id = 'evt' + eventCounter++;
  qArr.push(switcher);

  // useValuesFromTriggerTime
  let useValuesFromTriggerTime = x.attributes?.useValuesFromTriggerTime !== 'false';

  // trigger
  let trigger = x.elements?.find((y) => y.name === 'trigger');
  let triggerMath = trigger?.elements?.find((y) => y.name === 'math');
  if (triggerMath) {
    switcher.trigger = _toMathExpr(triggerMath);
  }

  // check if delay is presented, should we include it to Heta standard?
  let delay = x.elements?.find((y) => y.name === 'delay');
  // currently not used
  /*
  let delayMath = delay
    && delay.elements
    && delay.elements.find((y) => y.name === 'math');
  if (delayMath) {
    let delayExpr = _toMathExpr(delayMath);
    //console.log(delayExpr);

  }
  */
  if (delay !== undefined) {
    throw new HetaLevelError('"delay" in event is not supported in SBML module'); 
  }
  // assignments
  let assignments = x.elements?.find((y) => y.name === 'listOfEventAssignments');
  if (assignments?.elements !== undefined) {
    assignments.elements
      .filter((y) => y.name === 'eventAssignment')
      .forEach((y) => {
        let assign = {
          id: y.attributes?.variable,
          assignments: {}
        };

        let math = y.elements?.find((z) => z.name === 'math');
        if (math !== undefined) {
          assign.assignments[switcher.id] = _toMathExpr(math);
        }
        qArr.push(assign);
      });
  }

  return qArr;
}

function SBMLValueToNumber(value) {
  if (value.replace(/ /g, '') === 'INF') {
    return Infinity;
  } else if (value.replace(/ /g, '') === '-INF') {
    return -Infinity;
  } else if (value.replace(/ /g, '') === 'NaN') {
    return NaN;
  } else {
    return Number.parseFloat(value);
  }
}

module.exports = { SBMLParse };

1	const _toMathExpr = require('./to-math-expr');	1✔
2	const { xml2js } = require('xml-js');	1✔
3	const { Unit } = require('../core/unit');	1✔
4	const legalUnits = require('../legal-sbml-units');	1✔
5	const HetaLevelError = require('../heta-level-error');	1✔
6
7	/**
8	* Transforms text content of SBML file to Q-array.
9	*
10	* @param {string} fileContent SBML file content.
11	* @returns {array} Parsed content in Q-array format.
12	*/
13	function SBMLParse(fileText){
14	let JSBML = xml2js(fileText, { compact: false });	4✔
15
16	return jsbmlToQArr(JSBML);	4✔
17	}
18
19	/*
20	Converst of JSON image of SBML to Heta array
21	*/
22	function jsbmlToQArr(JSBML){
23	let qArr = [];	4✔
24	eventCounter = 0; // reset event counter	4✔
25
26	let sbml = JSBML.elements // <file>	4✔
27	.find((x) => x.name === 'sbml'); // <sbml>	4✔
28
29	let model = sbml.elements	4✔
30	.find((x) => x.name === 'model'); // <model>	4✔
31
32	// unit definition
33	let unitDict = {};	4✔
34	model.elements	4✔
35	.filter((x) => x.name === 'listOfUnitDefinitions')	12✔
36	.map((x) => x.elements)	2✔
37	.flat(1)
38	.filter((x) => x.name === 'unitDefinition')	7✔
39	.forEach((x) => {
40	unitDict[x.attributes.id] = unitDefinitionToUnits(x);	7✔
41	});
42
43	// algebraicRules
44
45	model.elements	4✔
46	.filter((x) => x.name === 'listOfFunctionDefinitions')	12✔
47	.map((x) => x.elements)	×
48	.flat(1)
49	.filter((x) => x.name === 'functionDefinition')	×
50	.forEach((x) => {
51	let q = functionDefinitionToQ(x);	×
52	qArr.push(q);	×
53	});
54
55	// species types, for IRT
56	model.elements	4✔
57	.filter((x) => x.name ==='listOfSpeciesTypes')	12✔
58	.map((x) => x.elements)	1✔
59	.flat(1)
60	.filter((x) => x.name === 'speciesType')	1✔
61	.forEach((x) => {
62	let q = speciesTypeToQ(x);	1✔
63	qArr.push(q);	1✔
64	});
65
66	// compartments
67	let zeroSpatialDimensions = [];	4✔
68	model.elements	4✔
69	.filter((x) => x.name === 'listOfCompartments')	12✔
70	.map((x) => x.elements)	2✔
71	.flat(1)
72	.filter((x) => x.name === 'compartment')	3✔
73	.forEach((x) => {
74	// collect compartments with zero dimention
75	let isZero = x.attributes?.spatialDimensions === '0';	3✔
76	if (isZero) {	3!
77	zeroSpatialDimensions.push(x.attributes?.id);	×
78	// set zero initial size
79	x.attributes = Object.assign({}, x.attributes, {size: '0'});	×
80	}
81
82	let q = compartmentToQ(x, unitDict);	3✔
83	qArr.push(q);	3✔
84	});
85
86	// species
87	model.elements	4✔
88	.filter((x) => x.name === 'listOfSpecies')	12✔
89	.map((x) => x.elements)	2✔
90	.flat(1)
91	.filter((x) => x.name === 'species')	6✔
92	.forEach((x) => {
93	let q = speciesToQ(x, zeroSpatialDimensions, qArr, unitDict);	6✔
94	qArr.push(q);	6✔
95	});
96
97	// reactions
98	model.elements	4✔
99	.filter((x) => x.name === 'listOfReactions')	12✔
100	.map((x) => x.elements)	1✔
101	.flat(1)
102	.filter((x) => x.name === 'reaction')	1✔
103	.forEach((x) => {
104	let qArr_add = reactionToQ(x);	1✔
105	qArr = qArr.concat(qArr_add);	1✔
106	});
107
108	// parameters
109	model.elements	4✔
110	.filter((x) => x.name === 'listOfParameters')	12✔
111	.map((x) => x.elements)	2✔
112	.flat(1)
113	.filter((x) => x.name === 'parameter')	6✔
114	.forEach((x) => {
115	let q = parameterToQ(x, unitDict);	6✔
116	qArr.push(q);	6✔
117	});
118
119	// initialAssignments
120	model.elements	4✔
121	.filter((x) => x.name === 'listOfInitialAssignments')	12✔
122	.map((x) => x.elements)	×
123	.flat(1)
124	.filter((x) => x.name === 'initialAssignment')	×
125	.forEach((x) => {
126	let q = initialAssignmentToQ(x);	×
127	qArr.push(q);	×
128	});
129
130	// assignmentRules
131	model.elements	4✔
132	.filter((x) => x.name === 'listOfRules')	12✔
133	.map((x) => x.elements)	1✔
134	.flat(1)
135	.filter((x) => x.name === 'assignmentRule')	44✔
136	.forEach((x) => {
137	let q = assignmentRuleToQ(x);	37✔
138	qArr.push(q);	37✔
139	});
140
141	// algebraicRules
142	let algebraicRules = model.elements	4✔
143	.filter((x) => x.name === 'listOfRules')	12✔
144	.map((x) => x.elements)	1✔
145	.flat(1)
146	.filter((x) => x.name === 'algebraicRule');	44✔
147	if (algebraicRules.length !== 0) {	4!
148	throw new HetaLevelError('"algebraicRule" from SBML module is not supported.');	×
149	}
150
151	// rateRules
152	model.elements	4✔
153	.filter((x) => x.name === 'listOfRules')	12✔
154	.map((x) => x.elements)	1✔
155	.flat(1)
156	.filter((x) => x.name === 'rateRule')	44✔
157	.forEach((x) => {
158	let qArr_add = rateRuleToQ(x);	×
159	qArr = qArr.concat(qArr_add);	×
160	});
161
162	// events
163	model.elements	4✔
164	.filter((x) => x.name === 'listOfEvents')	12✔
165	.map((x) => x.elements)	1✔
166	.flat(1)
167	.filter((x) => x.name === 'event')	1✔
168	.forEach((x) => {
169	let qs = eventToQ(x);	1✔
170	qArr = qArr.concat(qs);	1✔
171	});
172
173	return qArr;	4✔
174	}
175
176	/*
177	transform SBML-like unit definition to Heta-like unit array
178	*/
179	function unitDefinitionToUnits(x){
180	let units = x.elements	7✔
181	.filter((x) => x.name === 'listOfUnits')[0]	7✔
182	.elements
183	.map((element) => {
184	let { kind, multiplier, scale, exponent } = element.attributes;	8✔
185	return {	8✔
186	kind: kind,
187	multiplier: (multiplier \|\| 1) * 10**(scale \|\| 0),	27✔
188	exponent: parseInt(exponent) \|\| 1	15✔
189	};
190	});
191
192	return Unit.fromQ(units);	7✔
193	}
194
195
196	/*
197	transform SBML-like function definition to Heta-like unit array
198	*/
199	function functionDefinitionToQ(x) {
200
NEW 201	let q = {	×
202	action: 'defineFunction',
203	id: x.attributes.id
204	};
205
206	let mathElement = x.elements?.find((y) => y.name === 'math');	×
207	let lambdaElement = mathElement?.elements?.find((y) => y.name === 'lambda');	×
208
NEW 209	if (!mathElement \|\| !lambdaElement ) {	×
NEW 210	throw new HetaLevelError(`Heta does not support empty <math> or <lambda> "${q.id}" elements in FunctionDefinition,`);	×
211	}
212
213	// get argument ids
NEW 214	q.args = lambdaElement.elements	×
NEW 215	?.filter((y) => y.name === 'bvar')	×
216	.map((y) => y.elements && y.elements.find((z) => z.name === 'ci'))	×
217	.map((y) => y.elements && y.elements.find((z) => z.type === 'text'))	×
218	.map((y) => y.text.trim());	×
219
220	// get expression
NEW 221	let notBvarElement = lambdaElement.elements	×
NEW 222	?.find((y) => y.name !== 'bvar');	×
NEW 223	q.math = _toMathExpr(notBvarElement);	×
224
225
NEW 226	return q;	×
227	}
228
229	/*
230	Converts common properties to Heta Object
231	*/
232	function baseToQ(x){
233	let q = {	18✔
234	id: x.attributes?.id,
235	title: x.attributes?.name,
236	aux: {}
237	};
238	// set metaid
239	let metaid = x.attributes?.metaid;	18✔
240	if (metaid !== undefined) q.aux.metaid = metaid;	18!
241	// set sboTerm
242	let sboTerm = x.attributes?.sboTerm;	18✔
243	if (sboTerm !== undefined) q.aux.sboTerm = sboTerm;	18!
244	// take only first notes
245	let notes = x.elements?.find((y) => y.name === 'notes');	18✔
246	if (notes) q.notes = _toMarkdown(notes.elements);	18✔
247	// annotation
248	let annotation = x.elements?.find((y) => y.name === 'annotation');	18✔
249	if (annotation) q.aux.annotation = _toAux(annotation.elements);	18!
250
251	return q;	18✔
252	}
253
254	function _toMarkdown(elements = []){	×
255	let text = elements.map((x) => {	1✔
256	if (x.type === 'text') {	1!
257	return x.text.replace(/\r*\n/g, '');	1✔
258	} else {
259	switch (x.name) {	×
260	case 'body':
261	case 'div':
262	case 'p':
263	return _toMarkdown(x.elements) + '\n\n';	×
264	break;	×
265	case 'b':
266	case 'strong':
267	return '' + _toMarkdown(x.elements) + '';	×
268	break;	×
269	case 'i':
270	return '_' +_toMarkdown(x.elements) + '_';	×
271	break;	×
272	case 'ul': {
273	let list = x.elements.map((y) => ' * ' +_toMarkdown(y.elements))	×
274	.join('\n');
275	return list;	×
276	break;	×
277	}
278	case 'ol': {
279	let list = x.elements.map((y) => ' 1. ' +_toMarkdown(y.elements))	×
280	.join('\n');
281	return list;	×
282	break;	×
283	}
284	case 'a': {
285	let href = x.attributes?.href;	×
286	let title = x.attributes?.title;	×
287	return '[' + _toMarkdown(x.elements) + '](' + href + ')';	×
288	break;	×
289	}
290	case 'h1':
291	return '# ' + _toMarkdown(x.elements) + '\n\n';	×
292	break;	×
293	case 'h2':
294	return '## ' + _toMarkdown(x.elements) + '\n\n';	×
295	break;	×
296	case 'h3':
297	return '### ' + _toMarkdown(x.elements) + '\n\n';	×
298	break;	×
299	case 'h4':
300	return '#### ' + _toMarkdown(x.elements) + '\n\n';	×
301	break;	×
302	case 'h5':
303	return '##### ' + _toMarkdown(x.elements) + '\n\n';	×
304	break;	×
305	case 'h6':
306	return '###### ' + _toMarkdown(x.elements) + '\n\n';	×
307	break;	×
308	default:
309	return _toMarkdown(x.elements);	×
310	}
311	}
312	}).join('');
313
314	return text;	1✔
315	}
316
317	// TODO: use the same result as in SBMLViewer
318	function _toAux(elements){
319	return elements;	×
320	}
321
322	function speciesTypeToQ(x){
323	let q = baseToQ(x);	1✔
324	q.class = 'Component';	1✔
325
326	return q;	1✔
327	}
328
329	function compartmentToQ(x, unitDict = {}){	×
330	let q = baseToQ(x);	3✔
331
332	q.class = 'Compartment';	3✔
333	q.boundary = x.attributes?.constant !== 'false';	3✔
334	let num = x.attributes?.size;	3✔
335
336	if (num !== undefined) {	3!
337	q.assignments = { start_: SBMLValueToNumber(num) };	3✔
338	}
339	// units
340	let unitId = x.attributes?.units;	3✔
341	if (typeof unitId !== 'undefined') {	3!
342	let legalUnitIndex = legalUnits.indexOf(unitId); //	3✔
343	if (legalUnitIndex !== -1) { // if id in legal unit list	3✔
344	q.units = Unit.fromQ([{ kind: unitId }]);	1✔
345	} else if (unitDict[unitId] !== undefined){	2!
346	q.units = unitDict[unitId].simplify('dimensionless');	2✔
347	} else {
348	q.units = Unit.fromQ([{ kind: unitId }]);	×
349	// the alternative solution is to throw undeclared units
350	//throw new HetaLevelError(`No unitDeclaration "${unitId}" used for compartment "${q.id}"`);
351	}
352	}
353
354	// compartmentType
355	let compartmentType = x.attributes?.compartmentType;	3✔
356	if (compartmentType !== undefined) {	3!
357	q.tags = [compartmentType];	×
358	}
359
360	return q;	3✔
361	}
362
363	function speciesToQ(x, zeroSpatialDimensions = [], qArr = [], unitDict = {}){	×
364	let q = baseToQ(x);	6✔
365
366	q.class = 'Species';	6✔
367	q.boundary = x.attributes?.constant === 'true'	6✔
368	\|\| x.attributes?.boundaryCondition === 'true';
369	q.compartment = x.attributes?.compartment;	6✔
370	q.isAmount = x.attributes?.hasOnlySubstanceUnits === 'true'	6✔
371	\|\| zeroSpatialDimensions.indexOf(q.compartment) >= 0;
372	let concentration = x.attributes?.initialConcentration;	6✔
373	let amount = x.attributes?.initialAmount;	6✔
374	if (concentration !== undefined && !q.isAmount) {	6✔
375	q.assignments = { start_: SBMLValueToNumber(concentration) };	4✔
376	} else if (concentration !== undefined && q.isAmount) {	2!
377	q.assignments = { start_: SBMLValueToNumber(concentration) + '*' + q.compartment };	×
378	} else if (amount !== undefined && !q.isAmount) {	2!
379	q.assignments = { start_: SBMLValueToNumber(amount) + '/' + q.compartment };	2✔
380	} else if (amount !== undefined && q.isAmount) {	×
381	q.assignments = { start_: SBMLValueToNumber(amount) };	×
382	}
383	// speciesType
384	let speciesType = x.attributes?.speciesType;	6✔
385	if (speciesType !== undefined) q.tags = [speciesType];	6!
386
387	// units
388	let substanceUnitId = x.attributes?.substanceUnits;	6✔
389	if (typeof substanceUnitId !== 'undefined') {	6!
390	// find compartment units
391	let compartmentComponent = qArr.find((component) => component.id === q.compartment);	8✔
392	if (!compartmentComponent)	6!
393	throw new HetaLevelError(`Compartment "${q.compartment}" for "${q.id}" is not found in SBML`);	×
394	let compartmentUnits = compartmentComponent.units;	6✔
395
396	// set species units
397	let legalUnitIndex = legalUnits.indexOf(substanceUnitId);	6✔
398	if (legalUnitIndex !== -1) { // if id in legal unit list	6✔
399	let amountUnits = Unit.fromQ([{ kind: substanceUnitId }]);	3✔
400	if (q.isAmount) {	3!
401	q.units = amountUnits;	×
402	} else if (compartmentUnits !== undefined) {	3!
403	q.units = amountUnits	3✔
404	.divide(compartmentUnits)
405	.simplify();
406	}
407	} else if (unitDict[substanceUnitId] !== undefined) {	3!
408	let amountUnits = unitDict[substanceUnitId];	3✔
409	// set amount or concentration units
410	if (q.isAmount) {	3!
411	q.units = amountUnits	×
412	.simplify();
413	} else if (compartmentUnits !== undefined) {	3!
414	q.units = amountUnits	3✔
415	.divide(compartmentUnits)
416	.simplify();
417	}
418	} else {
419	let amountUnits = Unit.fromQ([{ kind: substanceUnitId }]);	×
420	if (q.isAmount) {	×
421	q.units = amountUnits;	×
422	} else if (compartmentUnits !== undefined) {	×
423	q.units = amountUnits	×
424	.divide(compartmentUnits)
425	.simplify();
426	}
427	// alternative solution is to throw error for undeclared "substance"
428	// throw new HetaLevelError(`No unitDeclaration "${substanceUnitId}" used for species "${q.id}"`);
429	}
430	}
431
432	return q;	6✔
433	}
434
435	function reactionToQ(x){
436	let qArr = [];	1✔
437	let localConstTranslate = [];	1✔
438	let q = baseToQ(x);	1✔
439
440	q.class = 'Reaction';	1✔
441
442	let kineticLaw = x.elements?.find((y) => y.name === 'kineticLaw');	3✔
443
444	// local parameters
445	let listOfParameters = kineticLaw?.elements?.find((y) => y.name === 'listOfParameters');	1✔
446	if (listOfParameters) {	1!
447	let parameters = listOfParameters.elements	×
448	.filter((y) => y.name = 'parameter');	×
449	parameters.forEach((y) => {	×
450	let id = y.attributes?.id;	×
451	let newId = id + '__' + q.id + '_local';	×
452	// set translator
453	localConstTranslate.push({id, newId});	×
454	// add component
455	qArr.push({	×
456	class: 'Const',
457	id: newId,
458	num: Number.parseFloat(y.attributes?.value)
459	});
460	});
461	}
462	// math
463	let math = kineticLaw?.elements?.find((y) => y.name === 'math');	1✔
464	if (math) {	1!
465	let expr = _toMathExpr(math);	1✔
466	localConstTranslate.forEach((y) => {	1✔
467	let regexp = new RegExp(`\\b${y.id}\\b`, 'g');	×
468	expr = expr.replace(regexp, y.newId);	×
469	});
470	q.assignments = { ode_: expr };	1✔
471	}
472
473	// check if reversible
474	q.reversible = x.attributes?.reversible !== 'false' ;	1✔
475
476	// check if fast
477	let fast = x.attributes?.fast === 'true' ;	1✔
478	// q.aux.fast = fast;
479	if (fast) {	1!
480	throw new HetaLevelError(`"fast" reactions "${q.id}" is not supported in SBML module.`);	×
481	}
482
483	// products
484	let products = x.elements?.find((y) => y.name === 'listOfProducts');	2✔
485	if (products?.elements) {	1!
486	var actors0 = products.elements	1✔
487	.filter((y) => y.name === 'speciesReference')	1✔
488	.map((y) => {
489	// check stoichiometry as an expression
490	let stoichiometryExpr = (y.elements \|\| [])	1✔
491	.filter((z) => z.name === 'stoichiometryMath');	×
492	if (stoichiometryExpr.length > 0)	1!
493	throw new HetaLevelError('"stoichiometryMath" from SBML module is not supported.');	×
494
495	// get constant stoichiometry
496	let stoichiometry = y.attributes?.stoichiometry \|\| '1';	1✔
497	return {	1✔
498	target: y.attributes?.species,
499	stoichiometry: Number.parseFloat(stoichiometry)
500	};
501	});
502	} else {
503	actors0 = [];	×
504	}
505
506	// reactants
507	let reactants = x.elements?.find((y) => y.name === 'listOfReactants');	1✔
508	if (reactants?.elements) {	1!
509	var actors1 = reactants.elements	1✔
510	.filter((y) => y.name === 'speciesReference')	1✔
511	.map((y) => {
512	// check stoichiometry as an expression
513	let stoichiometryExpr = (y.elements \|\| [])	1✔
514	.filter((z) => z.name === 'stoichiometryMath');	×
515	if (stoichiometryExpr.length > 0)	1!
516	throw new HetaLevelError('"stoichiometryMath" from SBML module is not supported.');	×
517
518	// get constant stoichiometry
519	let stoichiometry = y.attributes?.stoichiometry \|\| '1';	1✔
520	return {	1✔
521	target: y.attributes?.species,
522	stoichiometry: (-1) * Number.parseFloat(stoichiometry)
523	};
524	});
525	} else {
526	actors1 = [];	×
527	}
528
529	// modifiers
530	let modifiers1 = (x.elements?.find((y) => y.name === 'listOfModifiers')?.elements \|\| [])	3✔
531	.filter((y) => y.name === 'modifierSpeciesReference')	×
532	.map((y) => {
533	return { target: y.attributes?.species };	×
534	});
535
536	q.actors = actors0.concat(actors1);	1✔
537	q.modifiers = modifiers1;	1✔
538
539	// add reaction q
540	qArr.push(q);	1✔
541	return qArr;	1✔
542	}
543
544	function parameterToQ(x, unitDict = {}){	×
545	let q = baseToQ(x);	6✔
546
547	let isConstant = x.attributes?.constant === 'true';	6✔
548	let num = x.attributes?.value;	6✔
549	if (isConstant) {	6!
550	q.class = 'Const';	×
551	if (num !== undefined) {	×
552	q.num = SBMLValueToNumber(num);	×
553	}
554	} else {
555	q.class = 'Record';	6✔
556	if (num !== undefined) {	6!
557	q.assignments = { start_: SBMLValueToNumber(num) };	6✔
558	}
559	}
560
561	// units
562	let unitId = x.attributes?.units;	6✔
563	if (typeof unitId !== 'undefined') {	6!
564	let legalUnitIndex = legalUnits.indexOf(unitId); //	6✔
565	if (legalUnitIndex !== -1) { // if id in legal unit list	6✔
566	q.units = Unit.fromQ([{ kind: unitId }]);	2✔
567	} else if (unitDict[unitId] !== undefined) { // if id in unitDefinitions	4✔
568	// I removed simplify here to support pretty units in IRT
569	q.units = unitDict[unitId]; //.simplify();	3✔
570	} else {
571	q.units = Unit.fromQ([{ kind: unitId }]);	1✔
572	// alternative solution is to throw undeclared "unit"
573	//throw new HetaLevelError(`No unitDeclaration "${unitId}" as required for parameter "${q.id}"`);
574	}
575	}
576
577	return q;	6✔
578	}
579
580	function initialAssignmentToQ(x){
581	let q = {	×
582	id: x.attributes?.symbol,
583	};
584
585	let math = x.elements?.find((y) => y.name === 'math');	×
586	if (math !== undefined) {	×
587	q.assignments = {start_: _toMathExpr(math)};	×
588	}
589
590	return q;	×
591	}
592
593	function assignmentRuleToQ(x){
594	let q = {	37✔
595	id: x.attributes?.variable
596	};
597
598	let math = x.elements?.find((y) => y.name === 'math');	37✔
599	if (math !== undefined) {	37!
600	q.assignments = { ode_: _toMathExpr(math) };	37✔
601	}
602
603	return q;	37✔
604	}
605
606	function rateRuleToQ(x){
607	let q0 = baseToQ(x);	×
608
609	let target = x.attributes?.variable;	×
610	q0.id = target + '_proc';	×
611	q0.class = 'Process';	×
612	q0.actors = [{	×
613	stoichiometry: 1,
614	target: target
615	}];
616
617	let math = x.elements?.find((y) => y.name === 'math');	×
618	if (math !== undefined) {	×
619	q0.assignments = { ode_: _toMathExpr(math) };	×
620	}
621
622	// remove boundary for Species, because Heta does not change boundary species, but SBML does.
623	let q1 = { id: target, boundary: false };	×
624
625	return [q0, q1];	×
626	}
627
628	let eventCounter = 0;	1✔
629	function eventToQ(x){
630	let qArr = [];	1✔
631
632	let switcher = baseToQ(x);	1✔
633	switcher.class = 'DSwitcher';	1✔
634	if (switcher.id === undefined) switcher.id = 'evt' + eventCounter++;	1!
635	qArr.push(switcher);	1✔
636
637	// useValuesFromTriggerTime
638	let useValuesFromTriggerTime = x.attributes?.useValuesFromTriggerTime !== 'false';	1✔
639
640	// trigger
641	let trigger = x.elements?.find((y) => y.name === 'trigger');	1✔
642	let triggerMath = trigger?.elements?.find((y) => y.name === 'math');	1✔
643	if (triggerMath) {	1!
644	switcher.trigger = _toMathExpr(triggerMath);	1✔
645	}
646
647	// check if delay is presented, should we include it to Heta standard?
648	let delay = x.elements?.find((y) => y.name === 'delay');	2✔
649	// currently not used
650	/*
651	let delayMath = delay
652	&& delay.elements
653	&& delay.elements.find((y) => y.name === 'math');
654	if (delayMath) {
655	let delayExpr = _toMathExpr(delayMath);
656	//console.log(delayExpr);
657
658	}
659	*/
660	if (delay !== undefined) {	1!
661	throw new HetaLevelError('"delay" in event is not supported in SBML module');	×
662	}
663	// assignments
664	let assignments = x.elements?.find((y) => y.name === 'listOfEventAssignments');	2✔
665	if (assignments?.elements !== undefined) {	1!
666	assignments.elements	1✔
667	.filter((y) => y.name === 'eventAssignment')	1✔
668	.forEach((y) => {
669	let assign = {	1✔
670	id: y.attributes?.variable,
671	assignments: {}
672	};
673
674	let math = y.elements?.find((z) => z.name === 'math');	1✔
675	if (math !== undefined) {	1!
676	assign.assignments[switcher.id] = _toMathExpr(math);	1✔
677	}
678	qArr.push(assign);	1✔
679	});
680	}
681
682	return qArr;	1✔
683	}
684
685	function SBMLValueToNumber(value) {
686	if (value.replace(/ /g, '') === 'INF') {	15!
687	return Infinity;	×
688	} else if (value.replace(/ /g, '') === '-INF') {	15!
689	return -Infinity;	×
690	} else if (value.replace(/ /g, '') === 'NaN') {	15!
691	return NaN;	×
692	} else {
693	return Number.parseFloat(value);	15✔
694	}
695	}
696
697	module.exports = { SBMLParse };	1✔

hetalang / heta-compiler / 9367271584

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous