public Atom(string symbol)
{
Symbol = symbol;
switch (symbol)
{
case "He":
Number = 2;
Mass = 4.003m;
Type = AtomType.GasesNobre;
break;
case "O":
Number = 8;
Mass = 15.999m;
Type = AtomType.NaoMetal;
break;
case "H":
default:
Number = 1;
Mass = 1.008m;
Type = AtomType.NaoMetal;
break;
}
}
public void AddAtomCreation(DreamObject atom, ServerIconAppearance appearance)
{
AtomType atomType = AtomType.Atom;
if (atom.IsSubtypeOf(DreamPath.Area))
{
atomType = AtomType.Area;
}
else if (atom.IsSubtypeOf(DreamPath.Turf))
{
atomType = AtomType.Turf;
}
else if (atom.IsSubtypeOf(DreamPath.Mob))
{
atomType = AtomType.Movable;
}
else if (atom.IsSubtypeOf(DreamPath.Obj))
{
atomType = AtomType.Movable;
}
lock (_dreamStateManagerLock) {
_currentDeltaState.AddAtomCreation(DreamMetaObjectAtom.AtomIDs[atom], atomType, appearance.GetID());
}
}
public Atom(string element, AtomType type)
{
if (element == "*")
{
m_Element = ELEMENTS.WILD_CARD;
}
else if (element == "X")
{
m_Element = ELEMENTS.Halogen;
}
else
{
m_Element = (ELEMENTS)Enum.Parse(typeof(ELEMENTS), element);
}
m_ExplicitHydrogens = 0;
m_Isotope = 0;
m_Charge = 0;
m_Chiral = Chirality.UNSPECIFIED;
AtomType = type;
m_Chiral = Chirality.UNSPECIFIED;
if (this.Element != ELEMENTS.Halogen)
{
this.SetColor(SustainableChemistryWeb.ChemInfo.Element.ElementColor(m_Element));
}
else
{
Color = System.Drawing.Color.FromName("olivedrab");
}
_x = (int)(random.NextDouble() * 100);
_y = (int)(random.NextDouble() * 100);
//m_WeiningerInvariant = new WeiningerInvariant(this);
}
public static Molecule GetRandom(this Molecule[] soundsGroup, AtomType leadAtom, PositionType position)
{
return(soundsGroup
.Where(t => t.LeadType == leadAtom)
.ToWeightedDictionary(item => item.GetWeight(position))
.GetRandomItem());
}
public AtomData(Vector3 position, float electicValue, Color color, float size, AtomType atomType)
{
this.position = position;
this.electicValue = electicValue;
this.color = color;
this.size = size;
this.atomType = atomType;
}
public static string GetInjectableAtom(AtomType atom)
{
if (!typeNames.ContainsKey(atom))
{
throw new ArgumentOutOfRangeException(nameof(atom));
}
return(GetInjectableAtom(typeNames[atom], string.Empty));
}
public Molecule(string value, AtomType startsWith, AtomType endsWith, int leadWeight, int midWeight, int trailWeight)
{
Value = value;
LeadType = startsWith;
TrailType = endsWith;
LeadWeight = leadWeight;
MidWeight = midWeight;
TrailWeight = trailWeight;
}
public override void Render(HtmlNode parentElement, AtomType atomType)
{
var element = parentElement.OwnerDocument.CreateElement("a");
element.Attributes.Add(parentElement.OwnerDocument.CreateAttribute("href", "~/"));
element.AppendChild(parentElement.OwnerDocument.CreateTextNode(atomType.Text));
parentElement.AppendChild(element);
}
public void TestConfigure_IAtom_IAtomType()
{
IAtom atom = new Atom(ChemicalElement.C);
IAtomType atomType = new AtomType(ChemicalElement.C)
{
IsHydrogenBondAcceptor = true
};
AtomTypeManipulator.Configure(atom, atomType);
Assert.AreEqual(atomType.IsHydrogenBondAcceptor, atom.IsHydrogenBondAcceptor);
}
public void TestConfigureUnSetProperties()
{
IAtom atom = new Atom(ChemicalElement.C);
IAtomType atomType = new AtomType(ChemicalElement.C)
{
ExactMass = 12.0
};
AtomTypeManipulator.ConfigureUnsetProperties(atom, atomType);
Assert.AreEqual(12.0, atom.ExactMass.Value, 0.1);
}
public MpegAtom(MpegAtom parentAtom,
ArrayList childAtoms,
AtomType atomType,
long atomOffset,
uint atomSize)
{
Parent = parentAtom;
Children = childAtoms;
Type = atomType;
Offset = atomOffset;
Size = atomSize;
}
public void UnknownAtomTypeDoesNotModifyProperties()
{
IAtom atom = new Atom(ChemicalElement.C);
IAtomType atomType = new AtomType(ChemicalElement.R)
{
AtomTypeName = "X"
};
AtomTypeManipulator.Configure(atom, atomType);
Assert.AreEqual("C", atom.Symbol);
Assert.AreEqual(6, atom.AtomicNumber);
}
/// <summary>
/// Ctr.
/// </summary>
/// <param name="atomType">Atom type.</param>
/// <param name="name">The name to be used for parsing. See <see cref="Name"/>.</param>
/// <param name="expressionGenerator">The functor responsible for generating expressions.</param>
public AtomMetadata(AtomType atomType, string name, ExpressionGeneratorCallback expressionGenerator)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
ValidateExpressionGenerator(expressionGenerator);
AtomType = atomType;
Name = name;
ExpressionGenerator = expressionGenerator;
}
public LexicalMachineState GetNext(AtomType command)
{
LexicalMachineState nextState = this.CurrentState;
LexicalStateTransition transition = new LexicalStateTransition(CurrentState, command);
if (!transitions.TryGetValue(transition, out nextState))
{
throw new Exception("Lexical: Invalid transition: " + CurrentState + " -> " + command);
}
Console.WriteLine("Lexical :" + this.CurrentState + " -> " + nextState + " : " + command.ToString());
return(nextState);
}
public static string GetInjectableAtom(AtomType atom, AtomTarget target)
{
if (!targetNames.ContainsKey(target))
{
throw new ArgumentOutOfRangeException(nameof(target));
}
if (!typeNames.ContainsKey(atom))
{
throw new ArgumentOutOfRangeException(nameof(atom));
}
return(GetInjectableAtom(typeNames[atom], targetNames[target]));
}
public void AromaticityIsNotOverwritten()
{
IAtom atom = new Atom(ChemicalElement.C)
{
IsAromatic = true
};
IAtomType atomType = new AtomType(ChemicalElement.R)
{
IsAromatic = false,
AtomTypeName = "C.sp3"
};
AtomTypeManipulator.Configure(atom, atomType);
Assert.IsTrue(atom.IsAromatic);
}
public void AromaticitySetIfForType()
{
IAtom atom = new Atom(ChemicalElement.C)
{
IsAromatic = false
};
IAtomType atomType = new AtomType(ChemicalElement.R)
{
IsAromatic = true,
AtomTypeName = "C.am"
};
AtomTypeManipulator.Configure(atom, atomType);
Assert.IsTrue(atom.IsAromatic);
}
/// <summary>
/// Ctr.
/// </summary>
/// <param name="atomType">Atom type.</param>
/// <param name="name">The name to be used for parsing. See <see cref="Name"/>.</param>
/// <param name="functor">Functor responsible for extracting values from source. See <see cref="Functor"/>.</param>
public AtomMetadata(AtomType atomType, string name, object functor)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
ValidateFunctor(functor);
AtomType = atomType;
Name = name;
Functor = functor;
MethodInfo = GetMethodInfo(functor);
MethodTarget = GetMethodTarget(functor);
}
/// <summary>
/// Read atom header, add known flags.
/// </summary>
private AtomEvent ReadAtom()
{
// get size
uint sizeShort;
if (!TryReadUint(out sizeShort))
{
return(null); // end of stream
}
long size = sizeShort;
long dataSize = size - 8; // header length
// get type
string name = ReadAsciiStr(4);
if (string.IsNullOrEmpty(name))
{
return(null);
}
// check for wide atom
if (sizeShort == 0)
{
// Should not be hard to support it but dont need it yet.
throw new InvalidOperationException("Open atom not supported.");
}
if (sizeShort == 1)
{
// wide atom (should be "mdat")
ulong sizeLong;
if (!TryReadUlong(out sizeLong))
{
return(null); // end of stream
}
size = (long)sizeLong; // better to have size ulong, bot other methods expect long
dataSize = size - 16;
}
// get known flags
AtomTypeFlags flags = AtomTypeFlags.None;
AtomType type = Types.GetValueOrDefault(name);
if (type != null)
{
flags = type.Flags;
}
return(new AtomEvent(name, flags, size, dataSize));
}
public static AtomType Consume(Parser parser)
{
AtomType atomType = null;
switch (parser.LookAhead().Type)
{
case TokenInfo.TokenType.BOOL:
parser.Eat(TokenInfo.TokenType.BOOL);
atomType = new BoolType();
break;
case TokenInfo.TokenType.CHAR:
parser.Eat(TokenInfo.TokenType.CHAR);
atomType = new CharType();
break;
case TokenInfo.TokenType.DOUBLE:
parser.Eat(TokenInfo.TokenType.DOUBLE);
atomType = new DoubleType();
break;
case TokenInfo.TokenType.INT:
parser.Eat(TokenInfo.TokenType.INT);
atomType = new IntType();
break;
case TokenInfo.TokenType.STRING:
parser.Eat(TokenInfo.TokenType.STRING);
atomType = new StringType();
break;
case TokenInfo.TokenType.VOID:
parser.Eat(TokenInfo.TokenType.VOID);
atomType = new VoidType();
break;
default:
break;
}
if (atomType == null)
{
throw new ParserError(new FailedConsumer(), parser.Cursor);
}
return(atomType);
}
private List <AtomBehavior> GetStartingPointsByType(GameObject[] molecule, AtomType symbol)
{
List <AtomBehavior> atomsFound = new List <AtomBehavior>();
foreach (GameObject atom in molecule)
{
AtomBehavior atomScript = atom.GetComponent <AtomBehavior>();
if (atomScript.Symbol == symbol)
{
atomsFound.Add(atomScript);
}
}
Debug.Log("GetStartingPointsByType size : " + atomsFound.Count);
return(atomsFound);
}
private bool SameMoleculeAs(string index)
{
Debug.Log("SameMolecule : " + moleculeDictionary[index]);
// We retrieve a copy of the SMILES from the dictionary
string smiles = string.Copy(moleculeDictionary[index]);
// We retrieve the atoms in the molecule GameObject
GameObject[] atomsInMolecule = GameObject.FindGameObjectsWithTag("Atom");
Debug.Log("Atoms retrieved from molecule object : " + atomsInMolecule.Length);
// We retrieve the starting points of the recursion...
while (smiles[0] == '(')
{
smiles = smiles.Substring(1);
}
AtomType smilesStartingSymbol = GetSmilesStartingSymbol(ref smiles);
Debug.Log("SameMolecule starting symbol : " + smilesStartingSymbol);
List <AtomBehavior> startingPoints = GetStartingPointsByType(atomsInMolecule, smilesStartingSymbol);
// ...and start it from there
bool match = false;
foreach (AtomBehavior atom in startingPoints)
{
ResetAllMarks(atomsInMolecule);
if (CompareBranchFrom(ref smiles, atom))
{
match = true;
break;
}
}
// we clean all our atoms
ResetAllMarks(atomsInMolecule);
if (match)
{
Debug.Log("This molecule is " + index);
return(true);
}
else
{
Debug.Log("This molecule is not " + index);
return(false);
}
}
private void DrawNextAtom(AtomType type)
{
Wordbook saccadeBook = new Wordbook(calculatedSaccades);
AtomBook atomBook = new AtomBook(saccadeBook);
List <Atom> mediumLines = atomBook.atoms[type];
if (current < mediumLines.Count)
{
RemoveLabels();
RemoveFixationCircles();
RemoveSaccades();
DrawSaccades(mediumLines[current++].saccades);
}
else
{
current = 0;
}
}
// Lookup returns the atom whose name is s. It returns zero if there is no
// such atom. The lookup is case sensitive.
public static AtomType Lookup(byte[] s)
{
if (s.Length == 0 || s.Length > maxAtomLen)
{
return(0);
}
var h = fnv(hash0, s);
AtomType a = table[h & (uint)(table.Length - 1)];
if ((a & 0xff) == s.Length && match(a.ToStringUnsafe(), s))
{
return(a);
}
a = table[(h >> 16) & (uint)(table.Length - 1)];
if ((a & 0xff) == s.Length && match(a.ToStringUnsafe(), s))
{
return(a);
}
return(0);
}
public Atom(string element, AtomType type, int isotope, Chirality chirality, int hCount, int charge, int atomClass)
{
//degree = 0;
if (element == "*")
{
m_Element = ELEMENTS.WILD_CARD;
}
else
{
m_Element = (ELEMENTS)Enum.Parse(typeof(ELEMENTS), element);
}
m_ExplicitHydrogens = hCount;
m_Isotope = isotope;
m_Charge = charge;
m_Chiral = chirality;
AtomType = type;
this.SetColor(SustainableChemistryWeb.ChemInfo.Element.ElementColor(m_Element));
_x = (int)(random.NextDouble() * 100);
_y = (int)(random.NextDouble() * 100);
//m_WeiningerInvariant = new WeiningerInvariant(this);
}
public Atom(string element, AtomType type, Chirality chirality)
{
//degree = 0;
if (element == "*")
{
m_Element = ELEMENTS.WILD_CARD;
}
else
{
m_Element = (ELEMENTS)Enum.Parse(typeof(ELEMENTS), element);
}
m_ExplicitHydrogens = 0;
m_Isotope = 0;
m_Charge = 0;
m_Chiral = Chirality.UNSPECIFIED;
AtomType = AtomType.NONE;
m_Chiral = chirality;
this.SetColor(SustainableChemistryWeb.ChemInfo.Element.ElementColor(m_Element));
_x = (int)(random.NextDouble() * 100);
_y = (int)(random.NextDouble() * 100);
//m_WeiningerInvariant = new WeiningerInvariant(this);
}
public Atom(AtomType t)
{
t_ = t;
}
/// <summary>
/// Ctr.
/// </summary>
/// <param name="atomType">Atom type.</param>
/// <param name="name">The name to be used for parsing. See <see cref="Name"/>.</param>
/// <param name="expressionGenerator">The functor responsible for generating expressions.</param>
public AtomMetadata(AtomType atomType, string name, ExpressionGeneratorCallback expressionGenerator)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
ValidateExpressionGenerator(expressionGenerator);
AtomType = atomType;
Name = name;
ExpressionGenerator = expressionGenerator;
}
public LexicalStateTransition(LexicalMachineState currentState, AtomType command)
{
this.CurrentState = currentState;
this.Command = command;
}
/// <summary>
/// Ctr.
/// </summary>
/// <param name="atomType">Atom type.</param>
/// <param name="name">The name to be used for parsing. See <see cref="Name"/>.</param>
/// <param name="functor">Functor responsible for extracting values from source. See <see cref="Functor"/>.</param>
public AtomMetadata(AtomType atomType, string name, object functor)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
ValidateFunctor(functor);
AtomType = atomType;
Name = name;
Functor = functor;
MethodInfo = GetMethodInfo(functor);
MethodTarget = GetMethodTarget(functor);
}
public void TestButadiene()
{
var mol = new AtomContainer();
var carbon = new AtomType(ChemicalElement.C);
var a0 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 2
};
AtomTypeManipulator.ConfigureUnsetProperties(a0, carbon);
var a1 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a1, carbon);
var a2 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a2, carbon);
var a3 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 2
};
AtomTypeManipulator.ConfigureUnsetProperties(a3, carbon);
mol.Atoms.Add(a0);
mol.Atoms.Add(a1);
mol.Atoms.Add(a2);
mol.Atoms.Add(a3);
var b0 = new Bond(a0, a1)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b0);
var b1 = new Bond(a1, a2)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b1);
IBond b2 = new Bond(a2, a3)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b2);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
atasc.DecideBondOrder(mol, true);
Assert.AreEqual(BondOrder.Double, mol.Bonds[0].Order);
Assert.AreEqual(BondOrder.Single, mol.Bonds[1].Order);
Assert.AreEqual(BondOrder.Double, mol.Bonds[2].Order);
}
public void TestASimpleCarbonRing()
{
// First we create a simple carbon ring to play with...
var mol = new AtomContainer();
var carbon = new AtomType(ChemicalElement.C);
var a0 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a0, carbon);
var a1 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a1, carbon);
var a2 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a2, carbon);
var a3 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a3, carbon);
var a4 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a4, carbon);
var a5 = new Atom("C")
{
Hybridization = Hybridization.SP2,
ImplicitHydrogenCount = 1
};
AtomTypeManipulator.ConfigureUnsetProperties(a5, carbon);
mol.Atoms.Add(a0);
mol.Atoms.Add(a1);
mol.Atoms.Add(a2);
mol.Atoms.Add(a3);
mol.Atoms.Add(a4);
mol.Atoms.Add(a5);
var b0 = new Bond(a0, a1)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b0);
var b1 = new Bond(a1, a2)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b1);
var b2 = new Bond(a2, a3)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b2);
var b3 = new Bond(a3, a4)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b3);
var b4 = new Bond(a4, a5)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b4);
var b5 = new Bond(a5, a0)
{
IsSingleOrDouble = true
};
mol.Bonds.Add(b5);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
// ...then we send it to the method we want to test...
atasc.DecideBondOrder(mol, false);
Assert.AreEqual(BondOrder.Double, b0.Order);
Assert.AreEqual(BondOrder.Single, b1.Order);
Assert.AreEqual(BondOrder.Double, b2.Order);
Assert.AreEqual(BondOrder.Single, b3.Order);
Assert.AreEqual(BondOrder.Double, b4.Order);
Assert.AreEqual(BondOrder.Single, b5.Order);
Assert.IsTrue(satcheck.IsSaturated(a0, mol));
}
public override bool CanRender(AtomType atomType) => atomType.Name == "link";
