/
Referenced DSLs

Referenced DSLs

Owned by David Shields
Last updated: Nov 29, 2016

DSLs that create and reference intermediate results

LHS:

Assertion.Exists 
[when] Assertion.Exists - There is assertion {ASSERTION:ENUM:Assertion.value} = 
(
	Assertion(value == "{ASSERTION}")
) //DslUsed==Assertion.Exists.Dsl|||ASSERTION=={ASSERTION}
Assertion.Not.Exists 
[when] Assertion.Not.Exists - There is NOT an assertion {ASSERTION:ENUM:Assertion.value} = 
(
   java.util.List (size == 0) from collect ( Assertion(value == "{ASSERTION}") ) 
) //DslUsed==Assertion.Not.Exists.Dsl|||ASSERTION=={ASSERTION}
Assertion.String.Exists 
[when] Assertion.String.Exists - There is an Assertion String {ASSERTIONSTRING} = 
(
	//$assertions_{ASSERTIONSTRING} : Assertion
	Assertion
	(
		value == "{ASSERTIONSTRING}"
	)
) //DslUsed==Assertion.String.Exists|||ASSERTIONSTRING=={ASSERTIONSTRING}

RHS:

Assert 
[then] Assert - Assert to both Rules and Process that {ASSERTION:ENUM:Assertion.value} = 

insert(new Assertion("{ASSERTION}"));
assertions.add("{ASSERTION}"); //DslUsed==Assert.Dsl|||ASSERTION=={ASSERTION}
Assert.NamedDate 
[then] Assert.NamedDate - Assert name and value for Named Date {NAMEDDATENAME} for both Rules and Process = 

assertions.add("{NAMEDDATENAME}=" + org.opencds.common.utilities.DateUtility.getInstance().getDateAsSqlLongString(((java.util.Date) namedObjects.get("{NAMEDDATENAME}"))));

insert(new Assertion("{NAMEDDATENAME}=" + org.opencds.common.utilities.DateUtility.getInstance().getDateAsSqlLongString(((java.util.Date) namedObjects.get("{NAMEDDATENAME}"))))); //DslUsed==Assert.NamedDate.StNum.Dsl|||NAMEDDATENAME=={NAMEDDATENAME}
Assert.String 
[then] Assert.String - Assert String {ASSERTIONSTRING} for both Rules and Process = 
assertions.add("{ASSERTIONSTRING}");
insert(new Assertion("{ASSERTIONSTRING}")); //DslUsed==Assert.String.Dsl|||ASSERTIONSTRING=={ASSERTIONSTRING}

DSLs that control the Concept Determination Methods that you want to use in this Knowledge Module

LHS:

Concept.Det.Clin.Stmt.Identify 
[when] Concept.Det.Clin.Stmt.Identify - Concept for ClinicalStatement is not determined according to {DETERMETHOD:ENUM:VMRTemplateConcept.determinationMethodCode} = 
(
$ConceptDeterminationMethodClinicalStatementConceptToRemove{DETERMETHOD} : VmrOpenCdsConcept
	(
	determinationMethodCode != "{DETERMETHOD}"
	) and 
ClinicalStatement
	(
	id == $ConceptDeterminationMethodClinicalStatementConceptToRemove{DETERMETHOD}.conceptTargetId
	) 
) //DslUsed==Concept.Det.Clin.Stmt.Identify|||DETERMETHOD=={DETERMETHOD}
Concept.Det.Entity.Identify 
[when] Concept.Det.Entity.Identify - Concept for Entities is not determined according to {DETERMETHOD:ENUM:VMRTemplateConcept.determinationMethodCode} = 
(
$ConceptDeterminationMethodEntityConceptToRemove{DETERMETHOD} : VmrOpenCdsConcept
	(
	determinationMethodCode != "{DETERMETHOD}"
	) and 
EntityBase
	(
	id == $ConceptDeterminationMethodEntityConceptToRemove{DETERMETHOD}.conceptTargetId
	) 
) //DslUsed==Concept.Det.Entity.Identify.Dsl|||DETERMETHOD=={DETERMETHOD}
Concept.Det.Rship.Identify 
[when] Concept.Det.Rship.Identify - Concept for Relationship is not determined according to {DETERMETHOD:ENUM:VMRTemplateConcept.determinationMethodCode} = 
(
$ConceptDeterminationMethodRelationshipConceptToRemove{DETERMETHOD} : VmrOpenCdsConcept
	(
	determinationMethodCode != "{DETERMETHOD}"
	) and 
	( 
	ClinicalStatementRelationship
		(
		id == $ConceptDeterminationMethodRelationshipConceptToRemove{DETERMETHOD}.conceptTargetId
		) or 	
	EntityRelationship
		(
		id == $ConceptDeterminationMethodRelationshipConceptToRemove{DETERMETHOD}.conceptTargetId
		) 
	) 
) //DslUsed==Concept.Det.Rship.Identify.Dsl|||DETERMETHOD=={DETERMETHOD}

RHS:

Concept.Det.Clin.Stmt.Remove 
[then] Concept.Det.Clin.Stmt.Remove - Remove ClinicalStatement concept without desired concept determination method = 

retract ($ConceptDeterminationMethodClinicalStatementConceptToRemove{DETERMETHOD}); //DslUsed==Concept.Det.Clin.Stmt.Remove.Dsl|||DETERMETHOD=={DETERMETHOD}
Concept.Det.Entity.Remove 
[then] Concept.Det.Entity.Remove - Remove Entities concept without desired concept determination method = 
retract ($ConceptDeterminationMethodEntityConceptToRemove{DETERMETHOD}); //DslUsed==Concept.Det.Entity.Remove.Dsl|||DETERMETHOD=={DETERMETHOD}
Concept.Det.Rship.Remove 
[then] Concept.Det.Rship.Remove - Remove Relationship concept without desired concept determination method = 

retract ($ConceptDeterminationMethodRelationshipConceptToRemove{DETERMETHOD}); //DslUsed==Concept.Det.Rship.Remove.Dsl|||DETERMETHOD=={DETERMETHOD}

DSLs that select patient demographics in LHS:

Dem.Age.Time 
[when] Dem.Age.Time - Evaluated Person age was {COMP:ENUM:Comparison.operator} {N1} {TIMEUNITS1:ENUM:EnumerationTarget.javaCalendarUnit} at {N2} {TIMEUNITS2:ENUM:EnumerationTarget.javaCalendarUnit} {PLUSMINUS:ENUM:Comparison.plusMinus} {N3} {TIMEUNITS3:ENUM:EnumerationTarget.javaCalendarUnit} before evalTime, where time components are ignored if age unit is year, month, or day  = 
(
/*
	E.g., Evaluated Person age was [>=] [18][yr] at [8][mo] [+] [1][d] before evalTime, where time is ignored if age unit is yr, month, or day
*/ 
	EvaluatedPerson
	(
		id == $evaluatedPersonId, 
		demographics != null,
		eval(getAgeInTimeUnitAtTime(demographics.getBirthTime(), org.opencds.common.utilities.DateUtility.getInstance().getDateAfterAddingTime(org.opencds.common.utilities.DateUtility.getInstance().getDateAfterAddingTime($evalTime, {TIMEUNITS2}, -1 * {N2}), {TIMEUNITS3}, -1 * {PLUSMINUS}1 * {N3}), {TIMEUNITS1}) {COMP} {N1})
	)
) 
//DslUsed==Dem.Age.Time.Dsl||COMP=={COMP}|||N1=={N1}|||TIMEUNITS1=={TIMEUNITS1}|||N2=={N2}|||TIMEUNITS2=={TIMEUNITS2}|||PLUSMINUS=={PLUSMINUS}|||N3=={N3}|||TIMEUNITS3=={TIMEUNITS3}
Missing.DOB 
[when] Missing.DOB - EvaluatedPerson is missing date of birth = 
(
  (EvaluatedPerson(id == $evaluatedPersonId, demographics == null)) 
or
  (EvaluatedPerson(id == $evaluatedPersonId, demographics.birthTime == null))
)
//DslUsed==Missing.DOB.Dsl

DSLs that select encounters

LHS:

Enc.From.NamedList.After.Med.SubDispense.Count.Id 
[when] Enc.From.NamedList.After.Med.SubDispense.Count.Id - Evaluated Person had at least {INT1} {ENCLISTID:ENUM:EncounterListId.reference} from Named List "{NAMEDLIST}" where low time was at most {INT2} {TIMEUNITS2:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} after low time of {MED:ENUM:MedicationConcept.openCdsConceptCode} dispensation= 
(
	$EFNAMSDCI_MedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : java.util.List (size >= 0 ) from accumulate 
	( 
		MedicationConcept
		( 
			openCdsConceptCode == "{MED}",
			ESMPBECI_MedConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : conceptTargetId 
		),
	init (ArrayList $EFNAMSDCI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} = new ArrayList(); ),
	action ($EFNAMSDCI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.add(ESMPBECI_MedConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	reverse ($EFNAMSDCI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.remove(ESMPBECI_MedConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	result ($EFNAMSDCI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED})
	) and
	
	$EFNAMSDCI_SubDispenseEvents_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : java.util.List  (size >= 0) from collect 
	( 
		SubstanceDispensationEvent
		(
			evaluatedPersonId == $evaluatedPersonId, 
			id memberOf $EFNAMSDCI_MedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED},
			dispensationTime != null
		)
	) and
	
	NamedList
	(
		name == "{NAMEDLIST}", 
		list != null,
		list.size() >= 0,
		$EFNAMSDCI_Encounters_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : list == ( (List) (namedObjects.get("{NAMEDLIST}")))

	) and
	
	{ENCLISTID} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		$EFNAMSDCI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : EncounterEvent
		( 
			evaluatedPersonId == $evaluatedPersonId, 
			eval(encInEncList($EFNAMSDCI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}, $EFNAMSDCI_Encounters_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED},namedObjects)),
			eval(encAfterMedSubDispenseFromListWithinTime($EFNAMSDCI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}, $EFNAMSDCI_SubDispenseEvents_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} ,"Low","Low",{INT2},{TIMEUNITS2},namedObjects)) 
			
		),
	init (ArrayList $EFNAMSDCI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} = new ArrayList(); ),
	action ( $EFNAMSDCI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.add($EFNAMSDCI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	reverse ( $EFNAMSDCI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.remove($EFNAMSDCI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	result( $EFNAMSDCI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED})
	) 
	 
) //DslUsed==Enc.From.NamedList.After.Med.SubDispense.Count.Id|||INT1=={INT1}|||ENCLISTID=={ENCLISTID}|||NAMEDLIST=={NAMEDLIST}|||INT2=={INT2}|||TIMEUNITS2=={TIMEUNITS2}|||MED=={MED}
Enc.From.NamedList.After.Med.SubDispense.DaysSupply.Active.Count.Id 
[when] Enc.From.NamedList.After.Med.SubDispense.DaysSupply.Active.Count.Id - Evaluated Person had at least {INT1} {ENCLISTID:ENUM:EncounterListId.reference} from Named List "{NAMEDLIST}" where low time was at most {INT2} {TIMEUNITS2:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} after low time of {MED:ENUM:MedicationConcept.openCdsConceptCode} dispensation plus Days Supply= 
(
	$EFNAMSDDSACI_MedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : java.util.List (size >= 0 ) from accumulate 
	( 
		MedicationConcept
		( 
			openCdsConceptCode == "{MED}",
			ESMPBECI_MedConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : conceptTargetId 
		),
	init (ArrayList $EFNAMSDDSACI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} = new ArrayList(); ),
	action ($EFNAMSDDSACI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.add(ESMPBECI_MedConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	reverse ($EFNAMSDDSACI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.remove(ESMPBECI_MedConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	result ($EFNAMSDDSACI_TempMedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED})
	) and
	
	$EFNAMSDDSACI_SubDispenseEvents_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : java.util.List  (size >= 0) from collect 
	( 
		SubstanceDispensationEvent
		(
			evaluatedPersonId == $evaluatedPersonId, 
			id memberOf $EFNAMSDDSACI_MedConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED},
			dispensationTime != null,
			daysSupply != null
		)
	) and
	
	NamedList
	(
		name == "{NAMEDLIST}", 
		list != null,
		list.size() >= 0,
		$EFNAMSDDSACI_Encounters_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : list == ( (List) (namedObjects.get("{NAMEDLIST}")))

	) and
	
	{ENCLISTID} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		$EFNAMSDDSACI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} : EncounterEvent
		( 
			evaluatedPersonId == $evaluatedPersonId, 
			eval(encInEncList($EFNAMSDDSACI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}, $EFNAMSDDSACI_Encounters_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED},namedObjects)),
			eval(encAfterMedSubDispenseDaysSupplyActiveFromListWithinTime($EFNAMSDDSACI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}, $EFNAMSDDSACI_SubDispenseEvents_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} ,"Low",{INT2},{TIMEUNITS2},namedObjects)) 
			
		),
	init (ArrayList $EFNAMSDDSACI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED} = new ArrayList(); ),
	action ( $EFNAMSDDSACI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.add($EFNAMSDDSACI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	reverse ( $EFNAMSDDSACI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}.remove($EFNAMSDDSACI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED}); ),
	result( $EFNAMSDDSACI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{MED})
	) 	 
) //DslUsed==Enc.From.NamedList.After.Med.SubDispense.DaysSupply.Active.Count.Id|||INT1=={INT1}|||ENCLISTID=={ENCLISTID}|||NAMEDLIST=={NAMEDLIST}|||INT2=={INT2}|||TIMEUNITS2=={TIMEUNITS2}|||MED=={MED}
Enc.From.NamedList.Before.After.Enc.Rship.EncDx.Count.Id 
[when] Enc.From.NamedList.Before.After.Enc.Rship.EncDx.Count.Id - Evaluated Person had at least {INT1} {ENCLISTID:ENUM:EncounterListId.reference} from Named List "{NAMEDLIST}" where low time was at most {INT2} {TIMEUNITS2:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} after encounter high time AND high time was at most {INT3} {TIMEUNITS3:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} before encounter low time where {PROB:ENUM:ProblemConcept.openCdsConceptCode} was {CSREL:ENUM:ClinicalStatementRelationshipConcept.openCdsConceptCode} the encounter= 
// This DSL restricts Named List of encounters to those encounters which were time timeunits before or time timeunits after encounter that was related to EncDx
(
	$EFNAERECI_ProbConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		ProblemConcept
		( 
		openCdsConceptCode == "{PROB}",
		$EFNAERECI_ProbConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : conceptTargetId 
		),
	init (ArrayList $EFNAERECI_TempProbConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} = new ArrayList(); ),
	action ($EFNAERECI_TempProbConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.add($EFNAERECI_ProbConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	reverse ($EFNAERECI_TempProbConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.remove($EFNAERECI_ProbConceptTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	result($EFNAERECI_TempProbConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL})
	) and  
	
	$EFNAERECI_CSRelConceptProbTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		ClinicalStatementRelationshipConcept
		( 
		openCdsConceptCode == "{CSREL}",
		$EFNAERECI_CSRelConceptProbTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : conceptTargetId 
		),
	init (ArrayList $EFNAERECI_TempCSRelConceptProbTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} = new ArrayList(); ),
	action ( $EFNAERECI_TempCSRelConceptProbTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.add($EFNAERECI_CSRelConceptProbTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	reverse ( $EFNAERECI_TempCSRelConceptProbTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.remove($EFNAERECI_CSRelConceptProbTargetId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	result($EFNAERECI_TempCSRelConceptProbTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL})
	) and  
	
	$EFNAERECI_CSRelProbSourceIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		ClinicalStatementRelationship
		( 
		id memberOf $EFNAERECI_CSRelConceptProbTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL},
		targetId memberOf $EFNAERECI_ProbConceptTargetIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL},
		$EFNAERECI_CSRelProbSourceId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : sourceId 
		),
	init (ArrayList $EFNAERECI_TempCSRelProbSourceIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} = new ArrayList(); ),
	action ( $EFNAERECI_TempCSRelProbSourceIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.add($EFNAERECI_CSRelProbSourceId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	reverse ( $EFNAERECI_TempCSRelProbSourceIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.remove($EFNAERECI_CSRelProbSourceId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	result( $EFNAERECI_TempCSRelProbSourceIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL})
	) and  
	
	$EFNAERECI_ComorbidEncIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : java.util.List (size >= 0 ) from accumulate 
	( 
		EncounterEvent
		( 		
			$EFNAERECI_ComorbidEncId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : id memberOf $EFNAERECI_CSRelProbSourceIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}, 
			evaluatedPersonId == $evaluatedPersonId
		),
	init (ArrayList $EFNAERECI_TempComorbidEncIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} = new ArrayList(); ),
	action ( $EFNAERECI_TempComorbidEncIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.add($EFNAERECI_ComorbidEncId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	reverse ( $EFNAERECI_TempComorbidEncIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.remove($EFNAERECI_ComorbidEncId_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	result( $EFNAERECI_TempComorbidEncIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL})
	) and  
	
	$EFNAERECI_ComorbidEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : java.util.List( size >= {INT1} ) from collect 
	( 
		EncounterEvent
		(
			id memberOf $EFNAERECI_ComorbidEncIds_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}
		)
	) and
	
		NamedList
	(
		name == "{NAMEDLIST}", 
		list != null,
		list.size() >= 0,
		$EFNAERECI_Encounters_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : list == ( (List) (namedObjects.get("{NAMEDLIST}")))

	) and
	
	
	{ENCLISTID} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		$EFNAERECI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} : EncounterEvent
		( 
			evaluatedPersonId == $evaluatedPersonId, 
			eval(encInEncList($EFNAERECI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}, $EFNAERECI_Encounters_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL},namedObjects)),
			(
			eval(encAfterEncFromListWithinTime($EFNAERECI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}, $EFNAERECI_ComorbidEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL},"Low","High",{INT2},{TIMEUNITS2},namedObjects)) 
			|| 
			eval(encBeforeEncFromListWithinTime($EFNAERECI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}, $EFNAERECI_ComorbidEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL},"High","Low",{INT3},{TIMEUNITS3},namedObjects))
			)
		),
	init (ArrayList $EFNAERECI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL} = new ArrayList(); ),
	action ( $EFNAERECI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.add($EFNAERECI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	reverse ( $EFNAERECI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}.remove($EFNAERECI_Enc_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL}); ),
	result( $EFNAERECI_TempFinalEncs_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{TIMEUNITS2}{PROB}{CSREL})
	) 
	 
) //DslUsed==Enc.From.NamedList.Before.After.Enc.Rship.EncDx.Count.Id|||INT1=={INT1}|||ENCLISTID=={ENCLISTID}|||NAMEDLIST=={NAMEDLIST}|||INT2=={INT2}|||TIMEUNITS2=={TIMEUNITS2}|||INT3=={INT3}|||TIMEUNITS3=={TIMEUNITS3}|||PROB=={PROB}|||CSREL={CSREL}
Enc.From.NamedList.Rship.EncDx.Not.Multiple.Count.Id 
[when] Enc.From.NamedList.Rship.EncDx.Not.Multiple.Count.Id - Evaluated Person had at least {INT1} {ENCLISTID:ENUM:EncounterListId.reference} from Named List "{NAMEDLIST}" with more than {INT2} not a {PROB:ENUM:ProblemConcept.openCdsConceptCode} Encounter Diagnoses as {CSREL:ENUM:ClinicalStatementRelationshipConcept.openCdsConceptCode} the encounter = 
(
/*
This DSL restrict named list of encounters to those encounters which have more the INT2 Encounter Diagnosis
Variable pattern (change to XXX when editing): EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL}
*/
	NamedList
	(
		name == "{NAMEDLIST}", 
		list != null,
		list.size() >= 0,
		$Encs_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL} : list == ( (List) (namedObjects.get("{NAMEDLIST}")))
	) and
	
	// Collect Clinical Statement Relationships of Problems associated with previously defined encounters, constrained by evalPersonId and encounter diagnosis template
	// - Requires: $EncIds
	// - Provides: $EncProbCSRs
	
		$EncProbCSRConceptIds_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL} : java.util.List (size >= 0) from accumulate
		(	
			ClinicalStatementRelationshipConcept
			(	 
				openCdsConceptCode == "{CSREL}",
				$TempId : conceptTargetId 
			),
			init (ArrayList $TempIds = new ArrayList(); ), action ($TempIds.add($TempId); ), reverse ($TempIds.remove($TempId); ), result($TempIds)
		) and
		
	// Problems without problem concept and with encounter diagnosis template constraint, previously identified in relation to EncounterEvents
	// - Requires: $EncProbIds
	// - Provides: $ProbIds
			$ProbConceptTargetIds_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL} : java.util.List (size >= {INT1}) from accumulate
		(	
			ProblemConcept
			(	 
				openCdsConceptCode == "{PROB}",
				$TempId : conceptTargetId
			),
			init (ArrayList $TempIds = new ArrayList(); ), action ($TempIds.add($TempId); ), reverse ($TempIds.remove($TempId); ), result($TempIds)
		) and
		
		$EncProbIds_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL} : java.util.List (size >= 0) from accumulate
		(	
			Problem
			(
				evaluatedPersonId == $evaluatedPersonId, 
				id not memberOf $ProbConceptTargetIds_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL},
				eval((templateId != null) && java.util.Arrays.asList(templateId).contains("2.16.840.1.113883.3.1829.11.7.2.18")),
				$TempId : id
			),
			init (ArrayList $TempIds = new ArrayList(); ), action ($TempIds.add($TempId); ), reverse ($TempIds.remove($TempId); ), result($TempIds)
		) and

		$EncProbCSRs_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL} : java.util.List (size >= 0 ) from accumulate 
		( 
		$TempId : ClinicalStatementRelationship
			(	 
				id memberOf $EncProbCSRConceptIds_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL} ,
				eval((getIdListFromClinicalStatementList($Encs_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL})).contains(sourceId)),
				targetId memberOf $EncProbIds_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL} 
			),
		init (ArrayList $TempIds = new ArrayList(); ), action ($TempIds.add($TempId); ), reverse ($TempIds.remove($TempId); ), result($TempIds)
		) and	
	
	{ENCLISTID} : java.util.List (size >= {INT1} ) from accumulate 
		( 
		$TempId : EncounterEvent
			( 
				evaluatedPersonId == $evaluatedPersonId, 
				eval(encInEncList($TempId, $Encs_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL}, namedObjects)),
				eval(encMeetsCsrCountReq($TempId, $EncProbCSRs_EFNLREDNMCI_{INT1}{ENCLISTID}{NAMEDLIST}{INT2}{PROB}{CSREL},{INT2}))
			),
		init (ArrayList $TempIds = new ArrayList(); ), action ($TempIds.add($TempId); ), reverse ($TempIds.remove($TempId); ), result($TempIds)
		)
) //DslUsed==Enc.From.NamedList.After.EncDx.Count.Id|||INT1=={INT1}|||ENCLISTID=={ENCLISTID}|||NAMEDLIST=={NAMEDLIST}|||INT2=={INT2}|||PROB=={PROB}|||CSREL={CSREL}
Enc.Rship.EncDx.Between.Times.Count.Id 
[when] Enc.Rship.EncDx.Between.Times.Count.Id - Evaluated Person had at least {INT1} {ENCLISTID:ENUM:EncounterListId.reference} {ENCTYPE:ENUM:EncounterTypeConcept.openCdsConceptCode} with {HIGHLOW:ENUM:TimeInterval.highLowUpper} time at most {INT2} {TIMEUNITS2:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} and more than {INT3} {TIMEUNITS3:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} ago where {PROB:ENUM:ProblemConcept.openCdsConceptCode} was {CSREL:ENUM:ClinicalStatementRelationshipConcept.openCdsConceptCode} the encounter= 
(
/*
EncounterTypeConcept --> EncTypeConceptTargetIds --------------|                                
                                                                |          ProbIds, CSRelConceptTargetIds |              
ProbConcept --> ProbConceptTargetIds ---|                        |                                        --> FinalProbIds --> ProbList*
                                         --> ProbIds ---------------> CSRelSourceIds -------> FinalEncIds |--> EncList* 
                                                               |                       |
ClincialStatementRelationshipConcept --> CSRelConceptTargetIds |                       |
                                                                                      |
Encounter Date, Eval Person ID ------------------------------------------------------|

*flagged for return
       	
*/
	$EREDIBTC_EncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: java.util.List (size >= {INT1} ) from accumulate 
	( 
		EncounterTypeConcept
		( 
		openCdsConceptCode == "{ENCTYPE}",
		$EREDIBTC_EncTypeConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: conceptTargetId 
		),
	init (ArrayList $EREDIBTC_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}= new ArrayList(); ),
	action ($EREDIBTC_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.add($EREDIBTC_EncTypeConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	reverse ($EREDIBTC_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.remove($EREDIBTC_EncTypeConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	result($EREDIBTC_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL})
	) and  
	
	$EREDIBTC_ProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: java.util.List (size >= {INT1} ) from accumulate 
	( 
		ProblemConcept
		( 
		openCdsConceptCode == "{PROB}",
		$EREDIBTC_ProbConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: conceptTargetId 
		),
	init (ArrayList $EREDIBTC_TempProbConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}= new ArrayList(); ),
	action ($EREDIBTC_TempProbConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.add($EREDIBTC_ProbConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	reverse ($EREDIBTC_TempProbConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.remove($EREDIBTC_ProbConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	result($EREDIBTC_TempProbConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL})
	) and  
	
	$EREDIBTC_CSRelConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: java.util.List (size >= {INT1} ) from accumulate 
	( 
		ClinicalStatementRelationshipConcept
		( 
		openCdsConceptCode == "{CSREL}",
		$EREDIBTC_CSRelConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: conceptTargetId 
		),
	init (ArrayList $EREDIBTC_TempCSRelConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}= new ArrayList(); ),
	action ( $EREDIBTC_TempCSRelConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.add($EREDIBTC_CSRelConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	reverse ( $EREDIBTC_TempCSRelConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.remove($EREDIBTC_CSRelConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	result($EREDIBTC_TempCSRelConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL})
	) and  
	
	$EREDIBTC_CSRelSourceIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: java.util.List (size >= {INT1} ) from accumulate 
	( 
		ClinicalStatementRelationship
		( 
		id memberOf $EREDIBTC_CSRelConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL},
		targetId memberOf $EREDIBTC_ProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL},
		$EREDIBTC_CSRelSourceId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: sourceId memberOf $EREDIBTC_EncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}		
		),
	init (ArrayList $EREDIBTC_TempCSRelSourceIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}= new ArrayList(); ),
	action ( $EREDIBTC_TempCSRelSourceIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.add($EREDIBTC_CSRelSourceId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	reverse ( $EREDIBTC_TempCSRelSourceIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.remove($EREDIBTC_CSRelSourceId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	result( $EREDIBTC_TempCSRelSourceIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL})
	) and  
	
	$EREDIBTC_FinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: java.util.List (size >= {INT1} ) from accumulate 
	( 
		EncounterEvent
		( 
			$EREDIBTC_FinalEncId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: id memberOf $EREDIBTC_CSRelSourceIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}, 
			evaluatedPersonId == $evaluatedPersonId, 
			eval(timeBeforeByAtMost(encounterEventTime.get{HIGHLOW}(), $evalTime, {INT2}, {TIMEUNITS2}, namedObjects)),
			eval(timeBeforeByMoreThan(encounterEventTime.get{HIGHLOW}(), $evalTime, {INT3}, {TIMEUNITS3}, namedObjects))
		),
	init (ArrayList $EREDIBTC_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}= new ArrayList(); ),
	action ( $EREDIBTC_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.add($EREDIBTC_FinalEncId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	reverse ( $EREDIBTC_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.remove($EREDIBTC_FinalEncId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	result( $EREDIBTC_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL})
	) and  
	
	{ENCLISTID} : java.util.List( size >= {INT1} ) from collect 
	( 
		EncounterEvent
		(
			id memberOf $EREDIBTC_FinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}
		)
	) and
	
	$EREDIBTC_FinalProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: java.util.List (size >= {INT1} ) from accumulate 
	( 
		ClinicalStatementRelationship
		( 
			id memberOf $EREDIBTC_CSRelConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL},
			sourceId memberOf $EREDIBTC_FinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}, 
			$EREDIBTC_FinalProbId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: targetId memberOf $EREDIBTC_ProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}
		),
	init (ArrayList $EREDIBTC_TempFinalProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}= new ArrayList(); ),
	action ( $EREDIBTC_TempFinalProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.add($EREDIBTC_FinalProbId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	reverse ( $EREDIBTC_TempFinalProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}.remove($EREDIBTC_FinalProbId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}); ),
	result( $EREDIBTC_TempFinalProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL})
	) and 

	$EREDIBTC_ProbList_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}: java.util.List( size >= {INT1} ) from collect 
	( 
		Problem
		(
			id memberOf $EREDIBTC_FinalProbIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL}
		)
	) and
	
	EvaluatedPerson(eval(flagClinicalStatementListToReturnInOutput({ENCLISTID})), eval(flagClinicalStatementListToReturnInOutput($EREDIBTC_ProbList_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}{PROB}{CSREL})))
) //DslUsed==Enc.Rship.EncDx.Imp.Between.Times.Count.Id.Dsl|||INT1=={INT1}|||ENCLISTID=={ENCLISTID}|||ENCTYPE=={ENCTYPE}|||HIGHLOW=={HIGHLOW}|||INT2=={INT2}|||TIMEUNITS2=={TIMEUNITS2}|||INT3=={INT3}|||TIMEUNITS3=={TIMEUNITS3}|||PROB=={PROB}|||CSREL=={CSREL}|||PROBIMP=={PROBIMP}
Enc.Between.Times.Count.Id 
[when] Enc.Between.Times.Count.Id - Evaluated Person had at least {INT1} {ENCLISTID:ENUM:EncounterListId.reference} {ENCTYPE:ENUM:EncounterTypeConcept.openCdsConceptCode} with {HIGHLOW:ENUM:TimeInterval.highLowUpper} time at most {INT2} {TIMEUNITS2:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} and more than {INT3} {TIMEUNITS3:ENUM:EnumerationTarget.javaCalendarUnitNoWeeks} ago = 
(
	$EBTCI_EncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		EncounterTypeConcept
		( 
		openCdsConceptCode == "{ENCTYPE}",
		$EBTCI_EncTypeConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3} : conceptTargetId 
		),
	init (ArrayList $EBTCI_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3} = new ArrayList(); ),
	action ($EBTCI_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}.add($EBTCI_EncTypeConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}); ),
	reverse ($EBTCI_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}.remove($EBTCI_EncTypeConceptTargetId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}); ),
	result($EBTCI_TempEncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3})
	) and  
	
	$EBTCI_FinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3} : java.util.List (size >= {INT1} ) from accumulate 
	( 
		EncounterEvent
		( 
			$EBTCI_FinalEncId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3} : id memberOf $EBTCI_EncTypeConceptTargetIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}, 
			evaluatedPersonId == $evaluatedPersonId, 
			eval(timeBeforeByAtMost(encounterEventTime.get{HIGHLOW}(), $evalTime, {INT2}, {TIMEUNITS2}, namedObjects)),
			eval(timeBeforeByMoreThan(encounterEventTime.get{HIGHLOW}(), $evalTime, {INT3}, {TIMEUNITS3}, namedObjects))
		),
	init (ArrayList $EBTCI_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3} = new ArrayList(); ),
	action ( $EBTCI_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}.add($EBTCI_FinalEncId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}); ),
	reverse ( $EBTCI_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}.remove($EBTCI_FinalEncId_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}); ),
	result( $EBTCI_TempFinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3})
	) and  
	
	{ENCLISTID} : java.util.List( size >= {INT1} ) from collect 
	( 
		EncounterEvent
		(
			id memberOf $EBTCI_FinalEncIds_{INT1}{ENCLISTID}{ENCTYPE}{HIGHLOW}{INT2}{TIMEUNITS2}{INT3}{TIMEUNITS3}
		)
	) and
	EvaluatedPerson(eval(flagClinicalStatementListToReturnInOutput({ENCLISTID})))
) //DslUsed==Enc.Between.Times.Count.Id.Dsl|||INT1=={INT1}|||ENCLISTID=={ENCLISTID}|||ENCTYPE=={ENCTYPE}|||HIGHLOW=={HIGHLOW}|||INT2=={INT2}|||TIMEUNITS2=={TIMEUNITS2}|||INT3=={INT3}|||TIMEUNITS3=={TIMEUNITS3}

RHS:

Set.EncListId.Add.EncListRefs 
[then] Set.EncListId.Add.EncListRefs - Set {ENCLISTID1:ENUM:EncounterListId.reference} as {ENCLISTID2:ENUM:EncounterListId.reference} added to {ENCLISTID3:ENUM:EncounterListId.reference} = 
List {ENCLISTID1} = new ArrayList();
{ENCLISTID1}.addAll({ENCLISTID2});
{ENCLISTID1}.addAll({ENCLISTID3}); //DslUsed==Set.EncListId.Add.EncListRefs.Dsl|||ENCLISTID1=={ENCLISTID1}|||ENCLISTID2=={ENCLISTID2}|||ENCLISTID3=={ENCLISTID3}
Set.EncListId.EncListRefs.No.Time.Overlap 
[then] Set.EncListId.EncListRefs.No.Time.Overlap - Set {ENCLISTID1:ENUM:EncounterListId.reference} as the encounters in {ENCLISTID2:ENUM:EncounterListId.reference} with no time overlap with {ENCLISTID3:ENUM:EncounterListId.reference} = 
List {ENCLISTID1} = getEncListWithNoTimeOverlap({ENCLISTID2}, {ENCLISTID3}); //DslUsed==Set.EncListId.EncListRefs.No.Time.Overlap.Dsl|||ENCLISTID1=={ENCLISTID1}|||ENCLISTID2=={ENCLISTID2}|||ENCLISTID3=={ENCLISTID3}

DSLs that select Medications in LHS:

SubDispense.Med.Between.NamedDates.NoTimes 
[when] SubDispense.Med.Between.NamedDates.NoTimes.Count.Id - Evaluated Person had at least {INT1} {CSLISTID:ENUM:CSListId.reference} {MED:ENUM:MedicationConcept.openCdsConceptCode}  with {HIGHLOW:ENUM:TimeInterval.highLowUpper} dispensation time {COMP1:ENUM:Comparison.operatorGTE} {NAMEDDATE1NAME} and {COMP2:ENUM:Comparison.operatorLTE} {NAMEDDATE2NAME} ignoring time components of all dates = 
(
/*
This DSL collects a list of substance dispensation events that happened between named dates
Variable pattern (change to XXX when editing): SDMBNDNTCI_{INT1}{MED}{HIGHLOW}
*/
	NamedDate
	(
		name == "{NAMEDDATE1NAME}", 
		date != null,
		$NamedDate1_SDMBNDNTCI_{INT1}{MED}{HIGHLOW} : date == ((java.util.Date) namedObjects.get("{NAMEDDATE1NAME}"))
	) and

	NamedDate
	(
		name == "{NAMEDDATE2NAME}", 
		date != null,
		$NamedDate2_SDMBNDNTCI_{INT1}{MED}{HIGHLOW} : date == ((java.util.Date) namedObjects.get("{NAMEDDATE2NAME}"))
	) and

// Collect SubstanceDispensationEvents with medication concept, evalPersonId, and Named Dates
	// - Requires: None
	// - Provides: $SubDispenseEvents
	
	$MedConceptTargetIds_SDMBNDNTCI_{INT1}{MED}{HIGHLOW} : java.util.List (size >= 0 ) from accumulate 
	( 
		MedicationConcept
		( 
			openCdsConceptCode == "{MED}",
			$TempId : conceptTargetId 
		),
			init (ArrayList $TempIds = new ArrayList(); ), action ($TempIds.add($TempId); ), reverse ($TempIds.remove($TempId); ), result($TempIds)
	) and
	
	{CSLISTID}: java.util.List( size >= {INT1} ) from accumulate
	( 
		$TempId : SubstanceDispensationEvent
		(
			evaluatedPersonId == $evaluatedPersonId, 
			id memberOf $MedConceptTargetIds_SDMBNDNTCI_{INT1}{MED}{HIGHLOW},
			dispensationTime != null,
			(stripTimeComponent(dispensationTime.get{HIGHLOW}())) {COMP1} (stripTimeComponent($NamedDate1_SDMBNDNTCI_{INT1}{MED}{HIGHLOW})),
			(stripTimeComponent(dispensationTime.get{HIGHLOW}())) {COMP2} (stripTimeComponent($NamedDate2_SDMBNDNTCI_{INT1}{MED}{HIGHLOW})) 
		),
			init (ArrayList $TempIds = new ArrayList(); ), action ($TempIds.add($TempId); ), reverse ($TempIds.remove($TempId); ), result($TempIds)
	)


) //SubDispense.Med.Between.NamedDates.NoTimes.Count.Id|||INT1=={INT1}|||CSLISTID=={CSLISTID}|||MED=={MED}|||HIGHLOW=={HIGHLOW}|||COMP1=={COMP1}|||COMP2=={COMP2}|||NAMEDDATE1NAME=={NAMEDDATE1NAME}|||NAMEDDATE2NAME=={NAMEDDATE2NAME}

DSLs that create output structures

LHS:

Out.Concepts.All.Read 
[when] Out.Concepts.All.Read - All OpenCDS Concepts have been mapped to the vMR data = 
(
$concepts : java.util.Set (size >= 0) from collect ( VmrOpenCdsConcept() ) 
) //DslUsed==Out.Concepts.All.Read.Dsl

RHS:

Out.Concepts.All.Write 
[then] Out.Concepts.All.Write - Create output observation with ID {CONCEPTS} containing all OpenCDS Concepts in working memory selected above = 

IVLDate obsTime{CONCEPTS} = new IVLDate(); 
obsTime{CONCEPTS}.setLow($evalTime); 
obsTime{CONCEPTS}.setHigh($evalTime); 

ObservationResult parentObs{CONCEPTS} = new ObservationResult(); 
String parentObs{CONCEPTS}Id = "2.16.840.1.113883.3.795.5.1.1^{CONCEPTS}"; 
parentObs{CONCEPTS}.setId(parentObs{CONCEPTS}Id); 
parentObs{CONCEPTS}.setEvaluatedPersonId($evaluatedPersonId); 
parentObs{CONCEPTS}.setObservationEventTime(obsTime{CONCEPTS}); 
parentObs{CONCEPTS}.setSubjectIsFocalPerson($evaluatedPersonId == $focalPersonId); 

CD parentObs{CONCEPTS}Focus = new CD(); 
parentObs{CONCEPTS}Focus.setCodeSystem("2.16.840.1.113883.3.795.12.1.1"); 
parentObs{CONCEPTS}Focus.setCodeSystemName("OpenCDS concepts"); 
parentObs{CONCEPTS}Focus.setCode("concepts"); 
parentObs{CONCEPTS}Focus.setDisplayName("Concepts found in working memory"); 

parentObs{CONCEPTS}.setObservationFocus(parentObs{CONCEPTS}Focus); 
parentObs{CONCEPTS}.setClinicalStatementToBeRoot(true); 
parentObs{CONCEPTS}.setToBeReturned(true); 

ObservationValue obsValue{CONCEPTS} = new ObservationValue();

String conceptsAsString = getConceptsAsString($concepts);

obsValue{CONCEPTS}.setText(conceptsAsString);

parentObs{CONCEPTS}.setObservationValue(obsValue{CONCEPTS}); 
insert(parentObs{CONCEPTS}); 
namedObjects.put("parentObs{CONCEPTS}", (Object)parentObs{CONCEPTS}); //DslUsed==Out.Concepts.All.Write.Dsl|||CONCEPTS=={CONCEPTS}
Out.Assertions 
[then] Out.Assertions - Create output observation with ID {ASSERTIONS} containing a list of all assertions in working memory = 

IVLDate obsTime{ASSERTIONS} = new IVLDate(); 
obsTime{ASSERTIONS}.setLow($evalTime); 
obsTime{ASSERTIONS}.setHigh($evalTime); 

ObservationResult parentObs{ASSERTIONS} = new ObservationResult(); 
String parentObs{ASSERTIONS}Id = "2.16.840.1.113883.3.795.5.1.1^{ASSERTIONS}"; 
parentObs{ASSERTIONS}.setId(parentObs{ASSERTIONS}Id); 
parentObs{ASSERTIONS}.setEvaluatedPersonId($evaluatedPersonId); 
parentObs{ASSERTIONS}.setObservationEventTime(obsTime{ASSERTIONS}); 
parentObs{ASSERTIONS}.setSubjectIsFocalPerson($evaluatedPersonId == $focalPersonId); 

CD parentObs{ASSERTIONS}Focus = new CD(); 
parentObs{ASSERTIONS}Focus.setCodeSystem("2.16.840.1.113883.3.795.12.1.1"); 
parentObs{ASSERTIONS}Focus.setCodeSystemName("OpenCDS concepts"); 
parentObs{ASSERTIONS}Focus.setCode("assertions"); 
parentObs{ASSERTIONS}Focus.setDisplayName("Assertions found in working memory"); 

parentObs{ASSERTIONS}.setObservationFocus(parentObs{ASSERTIONS}Focus); 
parentObs{ASSERTIONS}.setClinicalStatementToBeRoot(true); 
parentObs{ASSERTIONS}.setToBeReturned(true); 

ObservationValue obsValue{ASSERTIONS} = new ObservationValue();

// obsValue{ASSERTIONS}.setText(assertions.toString());
// updated section
obsValue{ASSERTIONS}.setText(getAssertionsAsString(assertions));

parentObs{ASSERTIONS}.setObservationValue(obsValue{ASSERTIONS}); 
insert(parentObs{ASSERTIONS}); 
namedObjects.put("parentObs{ASSERTIONS}", (Object)parentObs{ASSERTIONS}); 
//DslUsed==Out.Assertions.Dsl|||ASSERTIONS=={ASSERTIONS}
Out.Nested.Obs.Num.Denom 
[then] Out.Nested.Obs.Num.Denom - Create numerator value {NUMVALUE} as ID {NUMID} and denominator value {DENOMVALUE} as ID {DENOMID} for output observations focused on {OBSFOCUS:ENUM:ObservationFocusConcept.openCdsConceptCode} within enclosing observation ID {ROOT} =
IVLDate obsTime{NUMID} = new IVLDate();
obsTime{NUMID}.setLow($evalTime);
obsTime{NUMID}.setHigh($evalTime);
 
ObservationResult childObs{NUMID} = new ObservationResult();
String childObs{NUMID}Id = "2.16.840.1.113883.3.795.5.1.1^{NUMID}";
 
childObs{NUMID}.setId(childObs{NUMID}Id);
childObs{NUMID}.setEvaluatedPersonId($evaluatedPersonId);
childObs{NUMID}.setObservationEventTime(obsTime{NUMID});
childObs{NUMID}.setSubjectIsFocalPerson($evaluatedPersonId == $focalPersonId);
childObs{NUMID}.setClinicalStatementToBeRoot(false);
childObs{NUMID}.setToBeReturned(true);
 
CD childObs{NUMID}Focus = new CD();
childObs{NUMID}Focus.setCodeSystem("2.16.840.1.113883.3.795.12.1.1");
childObs{NUMID}Focus.setCodeSystemName("OpenCDS concepts");
childObs{NUMID}Focus.setCode("{OBSFOCUS}");
childObs{NUMID}Focus.setDisplayName(getOpenCDSConceptName("{OBSFOCUS}"));
childObs{NUMID}.setObservationFocus(childObs{NUMID}Focus);
 
int iChildObs{NUMID} = {NUMVALUE};
INT childObs{NUMID}IntegerValue = new INT();
childObs{NUMID}IntegerValue.setValue(iChildObs{NUMID});
 
ObservationValue childObs{NUMID}Value = new ObservationValue();
childObs{NUMID}Value.setInteger(childObs{NUMID}IntegerValue);
childObs{NUMID}.setObservationValue(childObs{NUMID}Value);
 
ClinicalStatementRelationship rel{NUMID} = new ClinicalStatementRelationship();
rel{NUMID}.setSourceId("2.16.840.1.113883.3.795.5.1.1^{ROOT}");
rel{NUMID}.setTargetId("2.16.840.1.113883.3.795.5.1.1^{NUMID}");
 
CD rel{NUMID}Code = new CD();
rel{NUMID}Code.setCodeSystem("2.16.840.1.113883.3.795.12.1.1");
rel{NUMID}Code.setCodeSystemName("OpenCDS concepts");
rel{NUMID}Code.setCode("C405");
rel{NUMID}Code.setDisplayName("Part of");
rel{NUMID}.setTargetRelationshipToSource(rel{NUMID}Code);
 
java.util.List<RelationshipToSource> childObs{NUMID}RelationshipToSources = new java.util.ArrayList<RelationshipToSource>();
RelationshipToSource childObs{NUMID}RelationshipToSource = new RelationshipToSource();
 
childObs{NUMID}RelationshipToSource.setSourceId("2.16.840.1.113883.3.795.5.1.1^{ROOT}");
childObs{NUMID}RelationshipToSource.setRelationshipToSource(rel{NUMID}Code);
childObs{NUMID}RelationshipToSources.add(childObs{NUMID}RelationshipToSource);
childObs{NUMID}.setRelationshipToSources(childObs{NUMID}RelationshipToSources);
 
namedObjects.put("childObs{NUMID}", childObs{NUMID});
 
namedObjects.put("rel{NUMID}", rel{NUMID});
 
IVLDate obsTime{DENOMID} = new IVLDate();
obsTime{DENOMID}.setLow($evalTime);
obsTime{DENOMID}.setHigh($evalTime);
 
ObservationResult childObs{DENOMID} = new ObservationResult();
String childObs{DENOMID}Id = "2.16.840.1.113883.3.795.5.1.1^{DENOMID}";
 
childObs{DENOMID}.setId(childObs{DENOMID}Id);
childObs{DENOMID}.setEvaluatedPersonId($evaluatedPersonId);
childObs{DENOMID}.setObservationEventTime(obsTime{DENOMID});
childObs{DENOMID}.setSubjectIsFocalPerson($evaluatedPersonId == $focalPersonId);
childObs{DENOMID}.setClinicalStatementToBeRoot(false);
childObs{DENOMID}.setToBeReturned(true);
 
CD childObs{DENOMID}Focus = new CD();
childObs{DENOMID}Focus.setCodeSystem("2.16.840.1.113883.3.795.12.1.1");
childObs{DENOMID}Focus.setCodeSystemName("OpenCDS concepts");
childObs{DENOMID}Focus.setCode("{OBSFOCUS}");
childObs{DENOMID}Focus.setDisplayName(getOpenCDSConceptName("{OBSFOCUS}"));
childObs{DENOMID}.setObservationFocus(childObs{DENOMID}Focus);
 
int iChildObs{DENOMID} = {DENOMVALUE};
INT childObs{DENOMID}IntegerValue = new INT();
 
childObs{DENOMID}IntegerValue.setValue(iChildObs{DENOMID});
ObservationValue childObs{DENOMID}Value = new ObservationValue();
childObs{DENOMID}Value.setInteger(childObs{DENOMID}IntegerValue);
childObs{DENOMID}.setObservationValue(childObs{DENOMID}Value);
 
ClinicalStatementRelationship rel{DENOMID} = new ClinicalStatementRelationship();
rel{DENOMID}.setSourceId("2.16.840.1.113883.3.795.5.1.1^{ROOT}");
rel{DENOMID}.setTargetId("2.16.840.1.113883.3.795.5.1.1^{DENOMID}");
 
CD rel{DENOMID}Code = new CD();
rel{DENOMID}Code.setCodeSystem("2.16.840.1.113883.3.795.12.1.1");
rel{DENOMID}Code.setCodeSystemName("OpenCDS concepts");
rel{DENOMID}Code.setCode("C405");
rel{DENOMID}Code.setDisplayName("Part of");
rel{DENOMID}.setTargetRelationshipToSource(rel{DENOMID}Code);
 
java.util.List<RelationshipToSource> childObs{DENOMID}RelationshipToSources = new java.util.ArrayList<RelationshipToSource>();
RelationshipToSource childObs{DENOMID}RelationshipToSource = new RelationshipToSource();
 
childObs{DENOMID}RelationshipToSource.setSourceId("2.16.840.1.113883.3.795.5.1.1^{ROOT}");
childObs{DENOMID}RelationshipToSource.setRelationshipToSource(rel{DENOMID}Code);
childObs{DENOMID}RelationshipToSources.add(childObs{DENOMID}RelationshipToSource);
childObs{DENOMID}.setRelationshipToSources(childObs{DENOMID}RelationshipToSources);
 
namedObjects.put("childObs{DENOMID}", childObs{DENOMID});
 
namedObjects.put("rel{DENOMID}", rel{DENOMID}); //DslUsed==Out.Nested.Obs.Num.Denom.Dsl|||DENOMVALUE=={DENOMVALUE}|||DENOMID=={DENOMID}|||NUMVALUE=={NUMVALUE}|||NUMID=={NUMID}|||ROOT=={ROOT}|||OBSFOCUS=={OBSFOCUS}
Out.Root.Obs.Focus.EvalpId 
[then] Out.Root.Obs.Focus.EvalpId - Create root output observation with ID {ROOT} focused on {OUTROOTFOCUS:ENUM:ObservationFocusConcept.openCdsConceptCode} with value identifying the evaluatedPerson =
 
ObservationResult parentObs{ROOT} = new ObservationResult();
String parentObs{ROOT}Id = "2.16.840.1.113883.3.795.5.1.1^{ROOT}";
 
CD parentObs{ROOT}Focus = new CD();
parentObs{ROOT}Focus.setCodeSystem("2.16.840.1.113883.3.795.12.1.1");
parentObs{ROOT}Focus.setCodeSystemName("OpenCDS concepts");
parentObs{ROOT}Focus.setCode("{OUTROOTFOCUS}");
parentObs{ROOT}Focus.setDisplayName(getOpenCDSConceptName("{OUTROOTFOCUS}"));
 
ObservationValue parentObs{ROOT}Value = new ObservationValue();
String parentObs{ROOT}Identifier = $evaluatedPersonId;
parentObs{ROOT}Value.setIdentifier(parentObs{ROOT}Identifier);
 
IVLDate obsTime{ROOT} = new IVLDate();
obsTime{ROOT}.setLow($evalTime);
obsTime{ROOT}.setHigh($evalTime);
 
parentObs{ROOT}.setId(parentObs{ROOT}Id);
parentObs{ROOT}.setObservationFocus(parentObs{ROOT}Focus);
parentObs{ROOT}.setObservationValue(parentObs{ROOT}Value);
parentObs{ROOT}.setObservationEventTime(obsTime{ROOT});
parentObs{ROOT}.setEvaluatedPersonId($evaluatedPersonId);
parentObs{ROOT}.setSubjectIsFocalPerson($evaluatedPersonId == $focalPersonId);
parentObs{ROOT}.setClinicalStatementToBeRoot(true);
parentObs{ROOT}.setToBeReturned(true);
 
namedObjects.put("parentObs{ROOT}", parentObs{ROOT}); //DslUsed==Out.Root.Obs.Focus.EvalpId.Dsl|||ROOT=={ROOT}|||OUTROOTFOCUS=={OUTROOTFOCUS}

DSLs that initialize variables in LHS:

Init.EvalTime.FpId.EvalpId 
[when] Init.EvalTime.FpId.EvalpId - Note that all criteria below must be met for the rule to fire. = 
( EvalTime($evalTime : evalTimeValue) and FocalPersonId($focalPersonId : id) and FocalPersonId($evaluatedPersonId : id) ) 
//DslUsed==Init.EvalTime.FpId.EvalpId.Dsl

DSLs that create and inference on new generic facts

LHS:

NamedDate.Exists.Not.Null 
[when] NamedDate.Exists.Not.Null - The Named Date {NAME} exists and is not null = 
(
	NamedDate
	(
		name == "{NAME}", 
		date != null,
		date == ((java.util.Date) namedObjects.get("{NAME}"))
	)
) //DslUsed==NamedDate.Exists.Not.Null.Dsl|||NAME=={NAME}
NamedEnc.Exists.Not.Null 
[when] NamedEnc.Exists.Not.Null - The Named Encounter {NAME} exists and is not null = 
(
	NamedEncounter
	(
		name == "{NAME}", 
		encounter != null,
		namedObjects.get("{NAME}") != null, 
		encounter.id == ((EncounterEvent) namedObjects.get("{NAME}")).getId()	
	)
) //DslUsed==NamedEncounter.Exists.Not.Null.Dsl|||NAME=={NAME}
NamedList.Exists.EncListId 
[when] NamedList.Exists.EncListId - The Named List {ENCLISTID:ENUM:EncounterListId.reference} {NAME} exists; may be empty = 
(
	NamedList
	(
		name == "{NAME}", 
		list != null,
		{ENCLISTID} : list == ( (List) (namedObjects.get("{NAME}")))
	)
) //DslUsed==NamedList.Exists.EncListId.Dsl|||ENCLISTID=={ENCLISTID}|||NAME=={NAME}
NamedList.Exists.Not.Empty 
[when] NamedList.Exists.Not.Empty - The Named List {NAME} exists and is not empty = 
(
	NamedList
	(
		name == "{NAME}", 
		list != null,
		list.size() > 0,
		list == ( (List) (namedObjects.get("{NAME}")))
	)
) //DslUsed==NamedList.Exists.Not.Empty.Dsl|||NAME=={NAME}

RHS:

Insert.EncListRef.As.NamedList 
[then] Insert.EncListRef.As.NamedList - Insert {ENCLISTID:ENUM:EncounterListId.reference} as Named List "{NAME}" for both Rules and Process = 
namedObjects.put('{NAME}', {ENCLISTID});

NamedList  $namedList{ENCLISTID} = new NamedList();
$namedList{ENCLISTID}.setName('{NAME}');
$namedList{ENCLISTID}.setList({ENCLISTID}); 
insert ($namedList{ENCLISTID}); //DslUsed==Insert.EncListRef.As.NamedList.Dsl|||ENCLISTID=={ENCLISTID}|||NAME=={NAME}
Insert.NamedDate.After.NamedDate 
[then] Insert.NamedDate.After.NamedDate - Insert Named Date "{NAME}" for both Rules and Process which is {INT} {TIMEUNITS:ENUM:EnumerationTarget.javaCalendarUnit} after {NAMEDDATENAME}; requires NamedDate.Exists.Not.Null = 
/*
This DSL inserts a nameDate after another namedDate.
Variable pattern (change to XXX when editing): INDAND_{INT}{TIMEUNITS}    	
*/

java.util.Date sourcenamedDateValue_INDAND_{INT}{TIMEUNITS} = (java.util.Date) namedObjects.get("{NAMEDDATENAME}");
java.util.Date namedDateValue_INDAND_{INT}{TIMEUNITS} = org.opencds.common.utilities.DateUtility.getInstance().getDateAfterAddingTime(sourcenamedDateValue_INDAND_{INT}{TIMEUNITS}, {TIMEUNITS}, {INT});
namedObjects.put("{NAME}", namedDateValue_INDAND_{INT}{TIMEUNITS});

// System.out.println(">> Adding: <{NAME}> with value " + namedDateValue_INDAND_{INT}{TIMEUNITS}.toString()); 

NamedDate $namedDateAfterNamedDate_INDAND_{INT}{TIMEUNITS} = new NamedDate();
$namedDateAfterNamedDate_INDAND_{INT}{TIMEUNITS}.setName("{NAME}");
$namedDateAfterNamedDate_INDAND_{INT}{TIMEUNITS}.setDate(namedDateValue_INDAND_{INT}{TIMEUNITS}); 
insert ($namedDateAfterNamedDate_INDAND_{INT}{TIMEUNITS}); //DslUsed==Insert.NamedDate.After.NamedDate.Dsl|||NAME=={NAME}|||INT=={INT}|||TIMEUNITS=={TIMEUNITS}|||NAMEDDATENAME=={NAMEDDATENAME}
Insert.NamedDate.From.Earliest.Enc.In.NamedList 
[then] Insert.NamedDate.From.Earliest.Enc.In.NamedList - Insert Named Date "{NAME}" for both Rules and Process which is the earliest encounter {HIGHLOW:ENUM:TimeInterval.highLowUpper} time in {NAMEDLISTNAME}; requires NamedList.Exists.Not.Empty = 
List<EncounterEvent> namedListEncs = (List<EncounterEvent>) namedObjects.get("{NAMEDLISTNAME}");
java.util.Date namedDateValue = getEarliestDateFromEncounterList(namedListEncs, "{HIGHLOW}");
namedObjects.put("{NAME}", namedDateValue);

// System.out.println(">> Adding: <{NAME}> with value " + namedDateValue.toString()); 

NamedDate $INDFEEINL_NamedDate = new NamedDate();
$INDFEEINL_NamedDate.setName("{NAME}");
$INDFEEINL_NamedDate.setDate(namedDateValue); 
insert ($INDFEEINL_NamedDate); //DslUsed==Insert.NamedDate.From.Earliest.Enc.In.NamedList.Dsl|||NAME=={NAME}|||HIGHLOW=={HIGHLOW}|||NAMEDLISTNAME=={NAMEDLISTNAME}



Related content

Domain Specific Language (DSLs)
Domain Specific Language (DSLs)
OpenCDS
More like this
OpenCDS Functional Introduction
OpenCDS Functional Introduction
OpenCDS
More like this
Internal Data Model for Inferencing
Internal Data Model for Inferencing
OpenCDS
More like this
Testing OpenCDS Installation
Testing OpenCDS Installation
OpenCDS
More like this
Out.Root.Obs.Focus.EvalpId.Dsl
Out.Root.Obs.Focus.EvalpId.Dsl
OpenCDS
More like this
Functions
Functions
OpenCDS
More like this