PatternQuery:Principles - Revision history

Lukas at 13:45, 25 April 2015

2015-04-25T13:45:41Z

← Older revision		Revision as of 13:45, 25 April 2015
Line 87:		Line 87:
	[[Image:PatternQuery-Principles-Near.png\|center\|600px]]		[[Image:PatternQuery-Principles-Near.png\|center\|600px]]

	With these basic types of queries outlined in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of ~~motif~~ emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[PatternQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[PatternQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[PatternQuery:Language_Reference#Filter \| Filter()]]</code>.		With these basic types of queries outlined in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of pattern emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[PatternQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[PatternQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[PatternQuery:Language_Reference#Filter \| Filter()]]</code>.

	===A More Formal Description===		===A More Formal Description===

Lukas at 13:35, 25 April 2015

2015-04-25T13:35:19Z

← Older revision		Revision as of 13:35, 25 April 2015
Line 85:		Line 85:
	Finally, streams of patterns can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A apart. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new pattern from the 2 atoms is created. Therefore, the result of the above <code>[[PatternQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (patterns) that each contain two calcium atoms that are no further than 4A from each other:		Finally, streams of patterns can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A apart. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new pattern from the 2 atoms is created. Therefore, the result of the above <code>[[PatternQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (patterns) that each contain two calcium atoms that are no further than 4A from each other:

	[[Image:Near.png\|center\|600px]]		[[Image:PatternQuery-Principles-Near.png\|center\|600px]]

	With these basic types of queries outlined in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of motif emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[PatternQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[PatternQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[PatternQuery:Language_Reference#Filter \| Filter()]]</code>.		With these basic types of queries outlined in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of motif emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[PatternQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[PatternQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[PatternQuery:Language_Reference#Filter \| Filter()]]</code>.

Lukas at 13:31, 25 April 2015

2015-04-25T13:31:36Z

Show changes

Lukas: Lukas moved page MotiveQuery:Principles to PatternQuery:Principles

2015-04-25T12:56:08Z

Lukas moved page MotiveQuery:Principles to PatternQuery:Principles

← Older revision	Revision as of 12:56, 25 April 2015
(No difference)

Lukas at 14:25, 20 April 2015

2015-04-20T14:25:56Z

← Older revision		Revision as of 14:25, 20 April 2015
Line 83:		Line 83:
	The previous filter query also demonstrates another interesting concept of the language: the ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.		The previous filter query also demonstrates another interesting concept of the language: the ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.

	Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A ~~within each other~~. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other:		Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A apart. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other:

	[[Image:Near.png\|center\|600px]]		[[Image:Near.png\|center\|600px]]

Dave: /* A More Formal Description */

2015-02-24T10:38:20Z

A More Formal Description

← Older revision		Revision as of 10:38, 24 February 2015
Line 91:		Line 91:
	===A More Formal Description===		===A More Formal Description===
	There are two basic data structures that the language is built upon. These are:		There are two basic data structures that the language is built upon. These are:
	* '''Fragment'''. A fragment is ~~simple~~ an arbitrary set of atoms.		* '''Fragment'''. A fragment is simply an arbitrary set of atoms.
	* '''Fragment Sequence'''. A sequence of fragments. In mathematical terms, can be understood as a "set of fragments" which is another way of saying "set of sets of atoms".		* '''Fragment Sequence'''. A sequence of fragments. In mathematical terms, can be understood as a "set of fragments" which is another way of saying "set of sets of atoms".

Dave: /* Basic Principles of the Language */

2014-12-28T22:21:54Z

Basic Principles of the Language

← Older revision		Revision as of 22:21, 28 December 2014
Line 81:		Line 81:
	[[Image:MotiveQuery-Principles Atoms(Ca) surr filt.png\|center\|600px]]		[[Image:MotiveQuery-Principles Atoms(Ca) surr filt.png\|center\|600px]]

	The previous filter query also demonstrates another interesting concept of the language: ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.		The previous filter query also demonstrates another interesting concept of the language: the ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.

	Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A within each other. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other:		Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A within each other. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other:

Dave: /* Intuitive Description */

2014-12-28T22:21:16Z

Intuitive Description

← Older revision		Revision as of 22:21, 28 December 2014
Line 87:		Line 87:
	[[Image:Near.png\|center\|600px]]		[[Image:Near.png\|center\|600px]]

	With these basic types queries ~~outline~~ in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of motif emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[MotiveQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[MotiveQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[MotiveQuery:Language_Reference#Filter \| Filter()]]</code>.		With these basic types of queries outlined in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of motif emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[MotiveQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[MotiveQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[MotiveQuery:Language_Reference#Filter \| Filter()]]</code>.


	===A More Formal Description===		===A More Formal Description===

Dave: /* Example, Part One */

2014-12-24T17:03:35Z

Example, Part One

← Older revision		Revision as of 17:03, 24 December 2014
Line 16:		Line 16:
	if residue.IsHet():		if residue.IsHet():
	result.Add(residue)		result.Add(residue)
	</syntaxhighlight >		</syntaxhighlight>

	In the declarative approach, our code would look like this:		In the declarative approach, our code would look like this:

Dave: /* A More Formal Description */

2014-12-23T05:26:03Z

A More Formal Description

← Older revision		Revision as of 05:26, 23 December 2014
Line 98:		Line 98:
	* '''Generator queries'''. Generator queries, as the name suggests, generate sequences of fragments from the original input. They are the tool that transforms the input molecule into a stream of fragments that can be later modified or combined. Examples of these queries include <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code>, <code>[[MotiveQuery:Language_Reference#Residues \| Residues()]]</code>, and <code>[[MotiveQuery:Language_Reference#RegularMotifs \| RegularMotifs()]]</code>.		* '''Generator queries'''. Generator queries, as the name suggests, generate sequences of fragments from the original input. They are the tool that transforms the input molecule into a stream of fragments that can be later modified or combined. Examples of these queries include <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code>, <code>[[MotiveQuery:Language_Reference#Residues \| Residues()]]</code>, and <code>[[MotiveQuery:Language_Reference#RegularMotifs \| RegularMotifs()]]</code>.
	* '''Modifier queries'''. These queries operate on individual fragments and modify them or throw them away. Examples include <code>[[MotiveQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code>, <code>[[MotiveQuery:Language_Reference#ConnectedResidues \| ConnectedResidues()]]</code>, and <code>[[MotiveQuery:Language_Reference#Filter \| Filter()]]</code>.		* '''Modifier queries'''. These queries operate on individual fragments and modify them or throw them away. Examples include <code>[[MotiveQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code>, <code>[[MotiveQuery:Language_Reference#ConnectedResidues \| ConnectedResidues()]]</code>, and <code>[[MotiveQuery:Language_Reference#Filter \| Filter()]]</code>.
	* '''Combinator queries'''. Combinatorial queries take as input two or more sequence of fragments and combine them into a single new sequence that satisfies given criteria. Examples include <code>[[MotiveQuery:Language_Reference#Or \| Or()]]</code>, <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code>, and <code>[[MotiveQuery:Language_Reference#~~Star~~ \| ~~Star~~()]]</code>.		* '''Combinator queries'''. Combinatorial queries take as input two or more sequence of fragments and combine them into a single new sequence that satisfies given criteria. Examples include <code>[[MotiveQuery:Language_Reference#Or \| Or()]]</code>, <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code>, and <code>[[MotiveQuery:Language_Reference#Path \| Path()]]</code>.

	==Example, Revised==		==Example, Revised==

← Older revision		Revision as of 13:35, 25 April 2015
Line 85:		Line 85:
	Finally, streams of patterns can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A apart. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new pattern from the 2 atoms is created. Therefore, the result of the above <code>[[PatternQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (patterns) that each contain two calcium atoms that are no further than 4A from each other:		Finally, streams of patterns can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A apart. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new pattern from the 2 atoms is created. Therefore, the result of the above <code>[[PatternQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (patterns) that each contain two calcium atoms that are no further than 4A from each other:

	[[Image:Near.png\|center\|600px]]		[[Image:PatternQuery-Principles-Near.png\|center\|600px]]

	With these basic types of queries outlined in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of motif emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[PatternQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[PatternQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[PatternQuery:Language_Reference#Filter \| Filter()]]</code>.		With these basic types of queries outlined in the previous paragraphs, the sky's the limit. Due to the composable nature of the language if a new type of motif emerges, only a single function needs to be added to the language for it to work with all its other parts. As an example, assume we didn’t know that proteins had secondary structure called “sheet” and we just discovered it and a fancy algorithm to identify these "sheets". Now we would be interested in how this new type of protein substructure interacts with other parts of the molecule. All that would be needed is to add a function called <code>[[PatternQuery:Language_Reference#Sheets \| Sheets()]]</code> to the language and immediately we would be able to analyze and filter it’s neighborhood using the functions <code>[[PatternQuery:Language_Reference#AmbientAtoms \| AmbientAtoms()]]</code> and <code>[[PatternQuery:Language_Reference#Filter \| Filter()]]</code>.

← Older revision		Revision as of 14:25, 20 April 2015
Line 83:		Line 83:
	The previous filter query also demonstrates another interesting concept of the language: the ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.		The previous filter query also demonstrates another interesting concept of the language: the ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.

	Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A ~~within each other~~. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other:		Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A apart. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other:

	[[Image:Near.png\|center\|600px]]		[[Image:Near.png\|center\|600px]]

← Older revision		Revision as of 22:21, 28 December 2014
Line 81:		Line 81:
	[[Image:MotiveQuery-Principles Atoms(Ca) surr filt.png\|center\|600px]]		[[Image:MotiveQuery-Principles Atoms(Ca) surr filt.png\|center\|600px]]

	The previous filter query also demonstrates another interesting concept of the language: ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.		The previous filter query also demonstrates another interesting concept of the language: the ability to identify fragments within fragments, which is what the expression <code>m.Count(Atoms())</code> does - the <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> query is executed for each fragment from the original input sequence provided by the expression <code>Atoms('Ca').AmbientAtoms(4)</code>, and creates a new sequence of fragments that each contain a single atom. Then the Count function takes over and returns the number of fragments produced by its argument. In this way, the query <code>[[MotiveQuery:Language_Reference#Atoms \| Atoms()]]</code> inside the Count function can be replaced by any function that also produces a sequence of fragments, for example <code>[[MotiveQuery:Language_Reference#Rings \| Rings()]]</code>.

	Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A within each other. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other:		Finally, streams of fragments can be combined. For example, let’s say we want to find all pairs of calcium atoms that are no further than 4A within each other. This can be achieved using the query <code>Near(4, Atoms('Ca'), Atoms('Ca'))</code>. So this query takes as the input two identical streams of calcium atoms and for each pair of them determines if the atoms are closer than 4A to each other. For each pair that satisfies this condition, a new fragment from the 2 atoms is created. Therefore, the result of the above <code>[[MotiveQuery:Language_Reference#Near \| Near()]]</code> query is a stream of sets of atoms (fragments) that each contain two calcium atoms that are no further than 4A from each other: