/// <summary>
///
/// </summary>
/// <param name="domainInterfaceId"></param>
/// <param name="domainInterfaceTable"></param>
/// <param name="pdbpfamTable"></param>
/// <param name="chainAtomsHash"></param>
/// <returns></returns>
private DomainInterface ReadIntraDomainInterfaceFromChain(int domainInterfaceId, DataTable domainInterfaceTable,
DataTable pdbpfamTable, Dictionary <string, ChainAtoms> chainAtomsHash)
{
DomainInterface domainInterface = new DomainInterface();
DataRow[] domainInterfaceRows = domainInterfaceTable.Select(string.Format("DomainInterfaceID = '{0}'", domainInterfaceId));
if (domainInterfaceRows.Length > 0)
{
long domainId1 = Convert.ToInt64(domainInterfaceRows[0]["DomainID1"].ToString());
long domainId2 = Convert.ToInt64(domainInterfaceRows[0]["DomainID2"].ToString());
string asymChain = domainInterfaceRows[0]["AsymChain1"].ToString().TrimEnd();
if (chainAtomsHash.ContainsKey(asymChain))
{
ChainAtoms chain = chainAtomsHash[asymChain];
Range[] domainRanges1 = GetDomainRange(pdbpfamTable, domainId1);
Range[] domainRanges2 = GetDomainRange(pdbpfamTable, domainId2);
domainInterface.domainInterfaceId = domainInterfaceId;
domainInterface.firstSymOpString = asymChain + "_1_555";
domainInterface.secondSymOpString = asymChain + "_1_555";
domainInterface.domainId1 = domainId1;
domainInterface.domainId2 = domainId2;
domainInterface.chain1 = GetDomainAtoms(chain.CartnAtoms, domainRanges1);
domainInterface.chain2 = GetDomainAtoms(chain.CartnAtoms, domainRanges2);
domainInterface.GetInterfaceResidueDist();
}
}
return(domainInterface);
}
public CartController(IMessageSession _messageSession)
{
_domainInterface = new DomainInterface(_messageSession);
_modelSpec = new EnglishDictionary();
_equipment = EquipmentCollection.FromSampleFile(_modelSpec);
_invoiceSpec = new EnglishInvoice();
}
/// <summary>
///
/// </summary>
/// <param name="domainFile"></param>
/// <param name="domainInterface"></param>
private void ReadDomainIdFromFile(string domainFile, DomainInterface domainInterface)
{
StreamReader dataReader = new StreamReader(domainFile);
string line = "";
int domainIdx = -1;
int domainRangeIdx = -1;
long domainId1 = -1;
long domainId2 = -1;
while ((line = dataReader.ReadLine()) != null)
{
if (line.IndexOf("Domain 1") > -1)
{
domainIdx = line.IndexOf("Domain 1") + "Domain 1".Length;
domainRangeIdx = line.IndexOf("Domain Ranges");
domainId1 = Convert.ToInt64(line.Substring(domainIdx, domainRangeIdx - domainIdx));
}
if (line.IndexOf("Domain 2") > -1)
{
domainIdx = line.IndexOf("Domain 2") + "Domain 2".Length;
domainRangeIdx = line.IndexOf("Domain Ranges");
domainId2 = Convert.ToInt64(line.Substring(domainIdx, domainRangeIdx - domainIdx));
}
if (line.IndexOf("ATOM") > -1)
{
break;
}
}
dataReader.Close();
domainInterface.domainId1 = domainId1;
domainInterface.domainId2 = domainId2;
}
/// <summary>
///
/// </summary>
/// <param name="pdbId"></param>
/// <param name="intraChainDomainInterfaceIds"></param>
/// <returns></returns>
public DomainInterface[] GetIntraChainDomainInterfaces(string pdbId, int[] intraChainDomainInterfaceIds)
{
List <DomainInterface> domainInterfaceList = new List <DomainInterface> ();
if (intraChainDomainInterfaceIds.Length > 0)
{
string queryString = string.Format("Select * From PfamDomainInterfaces Where PdbID = '{0}' AND InterfaceID = 0;", pdbId);
DataTable entryIntraChainDomainInterfaceTable = ProtCidSettings.protcidQuery.Query(queryString);
queryString = string.Format("Select DomainID, SeqStart, SeqEnd From PdbPfam Where PdbID = '{0}';", pdbId);
DataTable pdbpfamTable = ProtCidSettings.pdbfamQuery.Query(queryString);
string[] asymChains = GetAsymChainsForIntraDomainInterfaces(entryIntraChainDomainInterfaceTable, intraChainDomainInterfaceIds);
Dictionary <string, ChainAtoms> chainAtomsHash = domainReader.ReadAtomsOfChains(pdbId, asymChains);
foreach (int domainInterfaceId in intraChainDomainInterfaceIds)
{
DomainInterface domainInterface = ReadIntraDomainInterfaceFromChain(domainInterfaceId, entryIntraChainDomainInterfaceTable, pdbpfamTable, chainAtomsHash);
domainInterfaceList.Add(domainInterface);
}
}
DomainInterface[] domainInterfaces = new DomainInterface[domainInterfaceList.Count];
domainInterfaceList.CopyTo(domainInterfaces);
return(domainInterfaces);
}
/// <summary>
/// domain interaction of the interface
/// </summary>
/// <param name="chainInterface"></param>
/// <param name="domainRange1"></param>
/// <param name="domainRange2"></param>
/// <returns></returns>
public DomainInterface GetDomainInterface(InterfaceChains chainInterface, Range[] domainRanges1, Range[] domainRanges2)
{
DomainInterface domainInterface = new DomainInterface(chainInterface);
domainInterface.chain1 = GetDomainAtoms(chainInterface.chain1, domainRanges1);
domainInterface.chain2 = GetDomainAtoms(chainInterface.chain2, domainRanges2);
domainInterface.seqDistHash =
GetResDistHash(chainInterface.seqDistHash, domainRanges1, domainRanges2);
return(domainInterface);
}
/// <summary>
///
/// </summary>
/// <param name="domainRow"></param>
/// <param name="pfamCode1"></param>
/// <param name="pfamCode2"></param>
/// <param name="chainInterfaces"></param>
/// <returns></returns>
private DomainInterface GetInterChainDomainInterface(DataRow domainInterfaceRow, string pfamCode1, string pfamCode2, InterfaceChains[] chainInterfaces)
{
string pdbId = domainInterfaceRow["PdbID"].ToString();
DomainInterface domainInterface = new DomainInterface();
int domainInterfaceId = Convert.ToInt32(domainInterfaceRow["DomainInterfaceID"].ToString());
string interfacePfam1 = "";
string interfacePfam2 = "";
Range[] domainRanges1 = GetDomainRange(pdbId, Convert.ToInt64(domainInterfaceRow["DomainID1"].ToString()), out interfacePfam1);
Range[] domainRanges2 = GetDomainRange(pdbId, Convert.ToInt64(domainInterfaceRow["DomainID2"].ToString()), out interfacePfam2);
int chainInterfaceId = Convert.ToInt32(domainInterfaceRow["InterfaceID"].ToString());
if (chainInterfaceId > 0) // inter-chain domain interface
{
InterfaceChains chainInterface = GetChainInterface(chainInterfaces, chainInterfaceId);
if (chainInterface != null)
{
domainInterface = GetDomainInterface(chainInterface, domainRanges1, domainRanges2);
}
}
if (domainInterface != null)
{
/* if (domainInterfaceRow["IsReversed"].ToString() == "1")
* {
* domainInterface.familyCode1 = pfamCode2;
* domainInterface.familyCode2 = pfamCode1;
* }
* else
* {
* domainInterface.familyCode1 = pfamCode1;
* domainInterface.familyCode2 = pfamCode2;
* }*/
domainInterface.domainInterfaceId = domainInterfaceId;
domainInterface.pdbId = pdbId;
domainInterface.interfaceId = chainInterfaceId;
domainInterface.domainId1 = Convert.ToInt64(domainInterfaceRow["DomainID1"].ToString());
domainInterface.domainId2 = Convert.ToInt64(domainInterfaceRow["DomainID2"].ToString());
domainInterface.familyCode1 = interfacePfam1;
domainInterface.familyCode2 = interfacePfam2;
// if the domain interface chain order is different from the pfam ids defined for the relation
// then reverse the interface chains
if (interfacePfam1 == pfamCode2 && interfacePfam2 == pfamCode1)
{
domainInterface.Reverse();
}
}
return(domainInterface);
}
/// <summary>
/// domain interaction of the interface
/// </summary>
/// <param name="chainInterface"></param>
/// <param name="domainRange1"></param>
/// <param name="domainRange2"></param>
/// <returns></returns>
private DomainInterface GetDomainInterface(InterfaceChains chainInterface, string domainRangeString1, string domainRangeString2)
{
DomainInterface domainInterface = new DomainInterface(chainInterface);
if (domainRangeString1 != "-" && domainRangeString2 != "-")
{
Range[] domainRanges1 = GetDomainRanges(domainRangeString1);
domainInterface.chain1 = GetDomainAtoms(domainInterface.chain1, domainRanges1);
Range[] domainRanges2 = GetDomainRanges(domainRangeString2);
domainInterface.chain2 = GetDomainAtoms(domainInterface.chain2, domainRanges2);
domainInterface.seqDistHash =
GetResDistHash(domainInterface.seqDistHash, domainRanges1, domainRanges2);
}
return(domainInterface);
}
/// <summary>
///
/// </summary>
/// <param name="domainInterface"></param>
public void ConvertInterfaceSeqNumbersToUnpNumbers(DomainInterface domainInterface)
{
string pdbId = domainInterface.pdbId;
int[] entities = null;
if (domainInterface.entityId1 == domainInterface.entityId2)
{
entities = new int[1];
entities[0] = domainInterface.entityId1;
}
else
{
entities = new int[2];
entities[0] = domainInterface.entityId1;
entities[1] = domainInterface.entityId2;
}
Dictionary <int, Dictionary <string, string> > entityPdbUnpSeqMatchDict = seqNumMatchData.ConvertPdbSeqNumbersToUnpNumbers(pdbId, entities);
Dictionary <string, string> entityPdbUnpSeqMatch1 = entityPdbUnpSeqMatchDict[domainInterface.entityId1];
for (int i = 0; i < domainInterface.chain1.Length; i++)
{
if (entityPdbUnpSeqMatch1.ContainsKey(domainInterface.chain1[i].seqId))
{
domainInterface.chain1[i].seqId = entityPdbUnpSeqMatch1[domainInterface.chain1[i].seqId];
}
else
{
domainInterface.chain1[i].seqId = "-1";
}
}
Dictionary <string, string> entityPdbUnpSeqMatch2 = entityPdbUnpSeqMatchDict[domainInterface.entityId2];
for (int i = 0; i < domainInterface.chain2.Length; i++)
{
if (entityPdbUnpSeqMatch2.ContainsKey(domainInterface.chain2[i].seqId))
{
domainInterface.chain2[i].seqId = entityPdbUnpSeqMatch2[domainInterface.chain2[i].seqId];
}
else
{
domainInterface.chain2[i].seqId = "-1";
}
}
}
/// <summary>
/// retrieve domain interfaces from crystal chain interfaces
/// </summary>
/// <param name="pdbId"></param>
/// <param name="familyCode"></param>
/// <param name="type"></param>
/// <returns></returns>
public DomainInterface[] GetInterChainDomainInterfaces(string pdbId, int relSeqId, int[] domainInterfaceIds, string type)
{
List <DomainInterface> domainInterfaceList = new List <DomainInterface> ();
if (domainInterfaceIds.Length > 0)
{
string queryString = string.Format("Select * From {0}DomainInterfaces " +
" Where RelSeqID = {1} AND PdbID = '{2}' AND InterfaceID > 0;", ProtCidSettings.dataType, relSeqId, pdbId);
DataTable domainInterfaceTable = ProtCidSettings.protcidQuery.Query(queryString);
Dictionary <int, List <int> > domainChainInterfaceIdHash = GetDomainChainInterfaceHash(domainInterfaceTable);
queryString = string.Format("Select * From {0}DomainFamilyRelation Where RelSeqId = {1};",
ProtCidSettings.dataType, relSeqId);
DataTable domainSeqIdTable = ProtCidSettings.protcidQuery.Query(queryString);
string pfamCode1 = domainSeqIdTable.Rows[0]["FamilyCode1"].ToString().Trim();
string pfamCode2 = domainSeqIdTable.Rows[0]["FamilyCode2"].ToString().Trim();
int[] chainInterfaceIds = GetInterChainInterfaceIDs(relSeqId, pdbId);
InterfaceChains[] chainInterfaces = null;
if (chainInterfaceIds.Length > 0)
{
chainInterfaces = GetCrystInterfaces(pdbId, chainInterfaceIds, type);
}
DomainInterface domainInterface = null;
foreach (int domainInterfaceId in domainChainInterfaceIdHash.Keys)
{
if (Array.IndexOf(domainInterfaceIds, domainInterfaceId) > -1)
{
DataRow[] domainInterfaceRows = domainInterfaceTable.Select("DomainInterfaceID = " + domainInterfaceId);
List <int> chainInterfaceIdList = domainChainInterfaceIdHash[domainInterfaceId];
if (chainInterfaceIdList.Count == 1) // inter-chain
{
domainInterface = GetInterChainDomainInterface(domainInterfaceRows[0], pfamCode1, pfamCode2, chainInterfaces);
if (domainInterface != null && domainInterface.seqDistHash.Count > 0)
{
domainInterfaceList.Add(domainInterface);
}
}
}
}
}
return(domainInterfaceList.ToArray());
}
/// <summary>
/// a list of domain interfaces for the input domainInterfaceIds
/// </summary>
/// <param name="srcDir"></param>
/// <param name="pdbId"></param>
/// <param name="domainInterfaceIds"></param>
/// <param name="type"></param>
/// <returns></returns>
public DomainInterface[] GetDomainInterfacesFromFiles(string srcDir, string pdbId, int[] domainInterfaceIds, string type)
{
DataTable pfamDomainTable = GetEntryPfamDomainTable(pdbId);
long domainId = 0;
List <DomainInterface> domainInterfaceList = new List <DomainInterface> ();
srcDir = Path.Combine(srcDir, pdbId.Substring(1, 2));
string gzDomainInterfaceFile = "";
string domainInterfaceFile = "";
string remark = "";
if (Directory.Exists(srcDir))
{
foreach (int dInterfaceId in domainInterfaceIds)
{
gzDomainInterfaceFile = Path.Combine(srcDir, pdbId + "_d" + dInterfaceId.ToString() + "." + type + ".gz");
if (File.Exists(gzDomainInterfaceFile))
{
InterfaceChains crystInterface = new InterfaceChains();
domainInterfaceFile = ParseHelper.UnZipFile(gzDomainInterfaceFile, ProtCidSettings.tempDir);
remark = ReadInterfaceChainsFromFile(domainInterfaceFile, ref crystInterface);
DomainInterface domainInterface = new DomainInterface(crystInterface);
domainInterface.pdbId = pdbId;
domainInterface.remark = remark;
domainInterface.domainInterfaceId = GetDomainInterfaceId(domainInterfaceFile);
string[] domainChainStrings = GetDomainChainStrings(remark);
domainId = Convert.ToInt64(domainChainStrings[0].Substring(0, domainChainStrings[0].IndexOf("_")));
domainInterface.domainId1 = domainId;
domainInterface.familyCode1 = GetPfamId(domainId, pfamDomainTable);
domainId = Convert.ToInt64(domainChainStrings[1].Substring(0, domainChainStrings[1].IndexOf("_")));
domainInterface.domainId2 = domainId;
domainInterface.familyCode2 = GetPfamId(domainId, pfamDomainTable);
File.Delete(domainInterfaceFile);
if (domainInterface.GetInterfaceResidueDist())
{
domainInterfaceList.Add(domainInterface);
}
}
}
}
return(domainInterfaceList.ToArray());
}
/// <summary>
/// domain interaction of the interface
/// </summary>
/// <param name="chainInterface"></param>
/// <param name="domainRange1"></param>
/// <param name="domainRange2"></param>
/// <returns></returns>
public DomainInterface GetDomainInterface(InterfaceChains chainInterface, Range[] domainRanges1, Range[] domainRanges2, bool isReversedChains)
{
DomainInterface domainInterface = new DomainInterface(chainInterface);
if (isReversedChains)
{
domainInterface.chain2 = GetDomainAtoms(chainInterface.chain1, domainRanges1);
domainInterface.chain1 = GetDomainAtoms(chainInterface.chain2, domainRanges2);
domainInterface.ResetSeqResidueHash();
}
else
{
domainInterface.chain1 = GetDomainAtoms(chainInterface.chain1, domainRanges1);
domainInterface.chain2 = GetDomainAtoms(chainInterface.chain2, domainRanges2);
domainInterface.seqDistHash =
GetResDistHash(chainInterface.seqDistHash, domainRanges1, domainRanges2);
}
return(domainInterface);
}
/// <summary>
/// get the cryst interfaces from the cryst interface files
/// </summary>
/// <param name="pdbId"></param>
/// <param name="pqsBuId"></param>
public DomainInterface[] GetDomainInterfacesFromFiles(string srcDir, string pdbId, string type)
{
DataTable pfamDomainTable = GetEntryPfamDomainTable(pdbId);
long domainId = 0;
string searchMode = pdbId + "*." + type + ".gz";
List <DomainInterface> domainInterfaceList = new List <DomainInterface> ();
if (Directory.Exists(srcDir))
{
string[] interfaceFiles = Directory.GetFiles(Path.Combine(srcDir, pdbId.Substring(1, 2)), searchMode);
string remark = "";
for (int i = 0; i < interfaceFiles.Length; i++)
{
InterfaceChains crystInterface = new InterfaceChains();
string domainInterfaceFile = ParseHelper.UnZipFile(interfaceFiles[i], ProtCidSettings.tempDir);
remark = ReadInterfaceChainsFromFile(domainInterfaceFile, ref crystInterface);
DomainInterface domainInterface = new DomainInterface(crystInterface);
domainInterface.pdbId = pdbId;
domainInterface.remark = remark;
domainInterface.domainInterfaceId = GetDomainInterfaceId(domainInterfaceFile);
string[] domainChainStrings = GetDomainChainStrings(remark);
domainId = Convert.ToInt64(domainChainStrings[0].Substring(0, domainChainStrings[0].IndexOf("_")));
domainInterface.domainId1 = domainId;
domainInterface.familyCode1 = GetPfamId(domainId, pfamDomainTable);
domainId = Convert.ToInt64(domainChainStrings[1].Substring(0, domainChainStrings[1].IndexOf("_")));
domainInterface.domainId2 = domainId;
domainInterface.familyCode2 = GetPfamId(domainId, pfamDomainTable);
File.Delete(domainInterfaceFile);
if (domainInterface.GetInterfaceResidueDist())
{
domainInterfaceList.Add(domainInterface);
}
}
}
return(domainInterfaceList.ToArray());
}
/// <summary>
/// domain-domain interactions with the relation in the BU
/// </summary>
/// <param name="domainInterfacesHash">domain interfaces for the BU</param>
/// <param name="biolUnitHash">the chains and atoms for the BU</param>
/// <returns>the domain-domain interfaces in the BU</returns>
private DomainInterface[] GetDomainInterfaces(Dictionary <int, DomainInterfaceComponent> domainInterfacesHash, Dictionary <string, AtomInfo[]> biolUnitHash)
{
List <DomainInterface> domainInterfaceList = new List <DomainInterface> ();
foreach (int domainInterfaceId in domainInterfacesHash.Keys)
{
DomainInterfaceComponent component = (DomainInterfaceComponent)domainInterfacesHash[domainInterfaceId];
AtomInfo[] domainAtoms1 = null;
AtomInfo[] domainAtoms2 = null;
foreach (string chainSymOpString in biolUnitHash.Keys)
{
if (component.chainSymOpString1 == chainSymOpString)
{
domainAtoms1 = GetDomainAtoms((AtomInfo[])biolUnitHash[chainSymOpString],
component.domainRange1);
}
if (component.chainSymOpString2 == chainSymOpString)
{
domainAtoms2 = GetDomainAtoms((AtomInfo[])biolUnitHash[chainSymOpString],
component.domainRange2);
}
}
DomainInterface domainInterface = new DomainInterface();
domainInterface.domainInterfaceId = domainInterfaceId;
domainInterface.interfaceId = component.chainInterfaceId;
domainInterface.chain1 = domainAtoms1;
domainInterface.chain2 = domainAtoms2;
domainInterface.firstSymOpString = component.chainSymOpString1;
domainInterface.secondSymOpString = component.chainSymOpString2;
domainInterface.domainId1 = component.domainId1;
domainInterface.domainId2 = component.domainId2;
domainInterface.familyCode1 = component.familyCode1;
domainInterface.familyCode2 = component.familyCode2;
domainInterface.GetInterfaceResidueDist();
domainInterfaceList.Add(domainInterface);
}
return(domainInterfaceList.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="pdbId"></param>
/// <param name="relSeqId"></param>
/// <param name="type"></param>
/// <returns></returns>
public DomainInterface[] GetInterChainDomainInterfaces(string pdbId, int relSeqId, string type)
{
string queryString = string.Format("Select * From {0}DomainInterfaces " +
" Where RelSeqID = {1} AND PdbID = '{2}' AND InterfaceID > 0;", ProtCidSettings.dataType, relSeqId, pdbId);
DataTable domainInterfaceTable = ProtCidSettings.protcidQuery.Query(queryString);
queryString = string.Format("Select * From {0}DomainFamilyRelation Where RelSeqId = {1};",
ProtCidSettings.dataType, relSeqId);
DataTable domainSeqIdTable = ProtCidSettings.protcidQuery.Query(queryString);
string family1 = domainSeqIdTable.Rows[0]["FamilyCode1"].ToString().Trim();
string family2 = domainSeqIdTable.Rows[0]["FamilyCode2"].ToString().Trim();
int[] chainInterfaceIds = GetInterChainInterfaceIDs(relSeqId, pdbId);
InterfaceChains[] chainInterfaces = GetCrystInterfaces(pdbId, chainInterfaceIds, type);
List <DomainInterface> domainInterfaceList = new List <DomainInterface> ();
Range[] domainRanges1 = null;
Range[] domainRanges2 = null;
int chainInterfaceId = -1;
int domainInterfaceId = -1;
string interfacePfam1 = "";
string interfacePfam2 = "";
bool isReversedChains = false;
foreach (DataRow domainRow in domainInterfaceTable.Rows)
{
isReversedChains = false;
DomainInterface domainInterface = new DomainInterface();
domainInterfaceId = Convert.ToInt32(domainRow["DomainInterfaceID"].ToString());
domainRanges1 = GetDomainRange(pdbId, Convert.ToInt64(domainRow["DomainID1"].ToString()), out interfacePfam1);
domainRanges2 = GetDomainRange(pdbId, Convert.ToInt64(domainRow["DomainID2"].ToString()), out interfacePfam2);
chainInterfaceId = Convert.ToInt32(domainRow["InterfaceID"].ToString());
InterfaceChains chainInterface = GetChainInterface(chainInterfaces, chainInterfaceId);
if (chainInterface == null)
{
continue;
}
// domain interface chains are in the different order of the corresponding chain interface chains
if (domainRow["IsReversed"].ToString() == "1")
{
isReversedChains = true;
domainInterface = GetDomainInterface(chainInterface, domainRanges2, domainRanges1, isReversedChains);
}
else
{
domainInterface = GetDomainInterface(chainInterface, domainRanges1, domainRanges2);
}
domainInterface.domainInterfaceId = domainInterfaceId;
domainInterface.pdbId = pdbId;
domainInterface.interfaceId = chainInterfaceId;
domainInterface.domainId1 = Convert.ToInt64(domainRow["DomainID1"].ToString());
domainInterface.domainId2 = Convert.ToInt64(domainRow["DomainID2"].ToString());
domainInterface.familyCode1 = interfacePfam1;
domainInterface.familyCode2 = interfacePfam2;
if (family2 != family1 && interfacePfam1 == family2 && interfacePfam2 == family1)
{
domainInterface.Reverse();
}
domainInterfaceList.Add(domainInterface);
}
return(domainInterfaceList.ToArray());
}
