public List<IACell> GetCellListByNetWorkType(GeoPolygonRegion region, List<Transceiver> allTranceiverList, float resolution, NetWorkType predictionType)
{
List<Transceiver> copy = new List<Transceiver>();
foreach (var item in allTranceiverList)
{
if (item.Cells[0] is LTECell)
{ copy.Add(item); }
}
List<IACell> list = new List<IACell>();
if (region == null)
{
list.AddRange(this.GetCellListByNetWorkType(copy, predictionType));
return list;
}
PredictionBound boundOfPolygon = this.GetBoundOfPolygon(region, resolution);
foreach (Transceiver transceiver in copy)
{
if (transceiver.Active && this.IsTranceiverInCalcZone(boundOfPolygon, transceiver))
{
foreach (IACell cell in transceiver.Cells)
{
if (cell.NetType == predictionType)
{
list.Add(cell);
}
}
}
}
return list;
}
public MCS()
{
this.m_Modulation = ModulationType.QPSK;
this.technology = NetWorkType.LTE;
this.m_ID = 0;
this.TBSIndex = 26;
}
public ServiceValidator(TrafficCollectionModel model, NetWorkType netType)
{
this.m_CsServiceManagement = model.UnionCsServiceManagement;
this.m_PsServiceManagement = model.UnionPsServiceManagement;
this.m_NetType = netType;
this.InitGenerateService();
}
/// <summary>
/// 获取下一个系统的所有仿真器
/// </summary>
/// <returns></returns>
public List<ISnapshot> GetNextNetworkSnapshots()
{
m_CurrentNetWorkType = m_CurrentQueue[0];
List<ISnapshot> snapshots = m_SnapshotDic[m_CurrentQueue[0]];
m_CurrentQueue.RemoveAt(0);
return snapshots;
}
static StackObject *InitNetWork_13(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 6);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
NetWorkType type = (NetWorkType)typeof(NetWorkType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
System.Single _DisConnTime = *(float *)&ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 3);
System.Single _HeartTime = *(float *)&ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 4);
System.Int32 port = ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 5);
System.String ip = (System.String) typeof(System.String).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 6);
App instance_of_this_method;
instance_of_this_method = (App)typeof(App).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
instance_of_this_method.InitNetWork(ip, port, _HeartTime, _DisConnTime, type);
return(__ret);
}
public ServiceUnionForm(TrafficCollectionModel model, Service service) : this()
{
this.m_Type = ProjectSingleton.CurrentProject.NetType;
List<NetWorkType> netWorkTypes = ProjectSingleton.ParseNetworkType(this.m_Type);
CommonServiceType serviceType = CommonServiceType.PSService;
if (null == service)
{
this.m_Control = new ServiceUnionControl(model, FormOpenType.New, null);
this.cmbType.SelectedIndex = 0;
this.SetGroupEnable(this.gbCS, false);
this.Text = TrafficModelResource.TRAFFICMODEL_UNIONSERVICE + " " + TrafficModelResource.TRAFFICMODEL_PROPERTY;
}
else
{
this.m_Control = new ServiceUnionControl(model, FormOpenType.Property, service);
serviceType = service.CommonType;
this.cmbType.Enabled = false;
this.m_OldName = service.Name;
this.m_OldServiceType = service.CommonType;
this.Text = this.m_Control.ServiceName + " " + TrafficModelResource.TRAFFICMODEL_PROPERTY;
}
this.cmbType.SelectedIndex = (serviceType == CommonServiceType.PSService) ? 0 : 1;
this.txbName.Text = this.m_Control.ServiceName;
this.InitPSService();
this.InitCSService();
this.SwitchServiceType(serviceType);
this.InitSingleEnable(netWorkTypes);
this.buttonApply.Enabled = false;
}
public void DeleteNetworkLegend(ISimulationGroup group, NetWorkType nt)
{
List<string> list = new List<string>();
string item = this.GetGroupNetworkTitle(group, nt);
list.Add(item);
this.m_LegendManagement.Clear("Simulation", list.ToArray());
}
public void CopyFrom(UnionPsService unionPsService)
{
this.m_BodyLoss = unionPsService.BodyLoss;
this.m_DlActivity = unionPsService.DlActivity;
this.m_DlAveThroughputDemand = unionPsService.DlAveThroughputDemand;
this.m_DlMaxThroughputDemand = unionPsService.DlMaxThroughputDemand;
this.m_DlMinThroughputDemand = unionPsService.DlMinThroughputDemand;
this.m_DlTxEff = unionPsService.DlTxEff;
this.UlOffset = unionPsService.UlOffset;
this.DlOffset = unionPsService.DlOffset;
this.m_Name = unionPsService.Name;
this.UlAMRRate = unionPsService.UlAMRRate;
this.DlAMRRate = unionPsService.DlAMRRate;
this.m_PSServiceDic.Clear();
foreach (KeyValuePair<NetWorkType, Service> pair in unionPsService.PSServiceDic)
{
this.m_PSServiceDic.Add(pair.Key, pair.Value);
}
this.m_Technology = unionPsService.Technology;
this.m_Type = unionPsService.Type;
this.m_UlActivity = unionPsService.UlActivity;
this.m_UlAveThroughputDemand = unionPsService.UlAveThroughputDemand;
this.m_UlMaxThroughputDemand = unionPsService.UlMaxThroughputDemand;
this.m_UlMinThroughputDemand = unionPsService.UlMinThroughputDemand;
this.m_UlTxEff = unionPsService.UlTxEff;
}
public ReceiveCIManagement(TrafficCollectionModel model, NetWorkType netType)
{
this.m_Model = model;
this.m_NetType = netType;
this.InitDataBaseDic();
this.GetDataFromNetType();
}
//private TreeNode[] ConvertTreeNodeCollectionToGroup(TreeNodeCollection col)
//{
// List<TreeNode> list = new List<TreeNode>();
// for (int i = 0; i < col.Count; i++)
// {
// list.Add(col[i].Clone() as TreeNode);
// }
// return list.ToArray();
//}
public string CreateNewProjectCanTest(string systemPath, NetWorkType type)
{
string str = string.Empty;
this.m_ProcessBarManager.ShowLoadingForm();
try
{
IAutoTestFunction iAut = null;
if (null != this.m_MainFormUIManager.MainForm.AutoTestManager.AutoTestSubSys)
{
iAut = this.m_MainFormUIManager.MainForm.AutoTestManager.AutoTestSubSys as IAutoTestFunction;
}
ProjectLogicMgr.Instance.CreateProject(systemPath, type, iAut);
MainFormSingleton.CurrentMainForm.ResourceMrgMenuItem.Visible = false;
string templateFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PrintConfiguration.xml");
this.m_MainFormUIManager.MainForm.PrintConfigCollection = new PrintSettingCollection(templateFile);
//print
PrintProject.Instance.PrintSeeting = this.m_MainFormUIManager.MainForm.PrintConfigCollection.GetDefaultPrintSetting();
ProjectSingleton.CurrentProject.ProjectSerializeData.PrintSeeting = PrintProject.Instance.PrintSeeting;
ProjectSingleton.CurrentProject.ProjectSerializeData.PSCollection = this.m_MainFormUIManager.MainForm.PrintConfigCollection;
}
catch (Exception)
{
this.m_ProcessBarManager.CloseLoadingForm();
return(FrameworkResource.PROJECT_CREATEPRJ_FAIL);
}
finally
{
this.m_ProcessBarManager.CloseLoadingForm();
}
this.BindProject();
this.m_MainFormUIManager.MainForm.SetStatusAfterCreateProject();
//this.StartDsSys();
return(str);
}
/// <summary>
/// 获取一个GSM用户到各个制式的总路损
/// </summary>
/// <param name="user"></param>
/// <param name="carrier"></param>
/// <param name="isDL"></param>
/// <returns></returns>
public float GetAllLoss(GSMSimUser user, ISimCellBase carrier, NetWorkType netType, bool isDL)
{
if (isDL)
return m_GetLinkLoss.GetLinkLoss(netType, carrier.Cell.ID, user.TrafficUser.Id, LinkType.Downlink);
else
return m_GetLinkLoss.GetLinkLoss(netType, carrier.Cell.ID, user.TrafficUser.Id, LinkType.Uplink);
}
private void CheckNetVersionInDic(NetWorkType workType)
{
bool isNetIn = m_CurrentNetworkDic.ContainsKey(workType);
if (!isNetIn)
{
m_CurrentNetworkDic.Add(workType, new List<NetVersion>());
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="netWorkType"></param>
public SuiteBuilder(NetWorkType netWorkType)
{
m_CaseInfoDic = new Dictionary<string, CaseConfigInfo>();
m_StudyRequiredCasesDic = new Dictionary<string, List<string>>();
m_NetWorkType = netWorkType;
IntialNetTypeDic();
IntialSuiteTypeDic();
}
/// <summary>
/// 构造函数
/// </summary>
public SnapshotBuilder(NetWorkType netType)
{
m_Snapshots = new List<ISnapshot>();
m_Results = new List<IResultManagement>();
m_SnapshotInfos = new List<SnapshotInfo>();
m_SnapshotTypes = new List<Type>();
m_ResultTypes = new List<Type>();
m_Type = netType;
}
private List<FrequencyBand> Convert2FreBand(NetWorkType type)
{
List<FrequencyBand> list = new List<FrequencyBand>();
foreach (FrequencyBand band in this.m_FreBandDic[type])
{
list.Add(band);
}
return list;
}
public ISimulationGroup CreateGroup(int id, string name, NetworkStyle ns, NetWorkType type)
{
ISimulationGroup group = new SimulationGroup(id);
group.Name = name;
group.NetworkType = type;
group.Style = ns;
return group;
}
private ServiceUnionForm()
{
this.components = null;
this.m_Control = null;
this.m_Type = NetWorkType.GSM;
this.m_OldName = string.Empty;
this.m_OldServiceType = CommonServiceType.PSService;
this.InitializeComponent();
}
public DisplayControl(CollectionsModel model, NetWorkType type)
{
this.InitializeComponent();
this.m_Editor = new DisplayControlEditor(this.dgvLegend, model, type);
this.m_UIModel = this.m_Editor.GetUIModel();
this.InitDrawDelegate();
this.BindDisplayTypeCombx();
this.m_UIModel.UpdataEvent += new EventHandler<EventArgs>(this.UIModel_UpdataEvent);
this.m_UIModel.UpdataTypeAndFieldEvent += new EventHandler<EventArgs>(this.UIModel_UpdataTypeAndFieldEvent);
}
public MCS(ModulationType modulationType, int modulationOrder, float codingRate, float bearEfficiency)
{
this.m_Modulation = ModulationType.QPSK;
this.technology = NetWorkType.LTE;
this.m_ID = 0;
this.m_Modulation = modulationType;
this.m_ModulationOrder = modulationOrder;
this.m_CodingRate = codingRate;
this.m_BearEfficiency = bearEfficiency;
}
private ProjectSerializeData(SerializationInfo info, StreamingContext context)
{
this.m_Name = info.GetString("m_Name");
this.m_NetType = (NetWorkType)info.GetValue("m_NetType", typeof(NetWorkType));
this.m_PrintSeeting = (info.GetValue("m_PrintSeeting", typeof(PrintSetting)) as PrintSetting);
this.m_ProjectIPLFile = info.GetString("m_ProjectIPLFile");
this.m_PSCollection = (info.GetValue("m_PSCollection", typeof(PrintSettingCollection)) as PrintSettingCollection);
this.m_Version = info.GetString("m_Version");
this.m_AllSubSysData = (info.GetValue("m_AllSubSysData", typeof(List <ISubSystemData>)) as List <ISubSystemData>);
}
private void ReadOneNodeInfo(XmlDocument configFile,NetWorkType type)
{
string XPath = string.Format(XPATH_NetVersion, type.ToString());
XmlNodeList nodes = configFile.SelectNodes(XPath);
foreach (XmlNode node in nodes)
{
AddNetVersion(node);
}
}
public NetworkTerminal GetNetWorkTerminal(NetWorkType networktype)
{
foreach (NetworkTerminal terminal in this.m_NetTerminalList)
{
if (terminal.NetType == networktype)
{
return terminal;
}
}
return null;
}
public List<FrequencyBand> GetFrequncyBand(NetWorkType type)
{
foreach (NetWorkType type2 in Enum.GetValues(typeof(NetWorkType)))
{
if (type == (type2 & type))
{
return this.Convert2FreBand(type2);
}
}
return null;
}
public FiledDisplayForm(CollectionsModel model, NetWorkType network)
{
this.m_DisplayControl = new DisplayControl(model, network);
this.m_DisplayControl.EnableApplyEvent += new EventHandler<EventArgs>(this.DisplayControl_EnableApplyEvent);
this.InitializeComponent();
this.m_NetEntityEvent = model.GisINetEntity;
this.m_Editor = new FiledDisplayFormEditor(model, network);
this.BulidSiteNode();
this.LoadData(new Huawei.UNet.NE.Model.GisDisPlay());
this.button_Apply.Enabled = false;
}
public IPredictionGroup CreateGroup(List<StudyTemplate> studyTemplateList, string groupName, int groupID, NetWorkType predictionType)
{
TDPredictionGroup tdGroup = new TDPredictionGroup();
tdGroup.Name = groupName;
tdGroup.GroupId = groupID;
tdGroup.PredictionType = predictionType;
tdGroup.appContext = m_AppContext;
tdGroup.State = CalculateState.Indeterminate;
InitStudyList(studyTemplateList, tdGroup);
return tdGroup;
}
public void SetNetworkType(NetWorkType netType)
{
this.ProjectSerializeData.NetType = netType;
foreach (IGeneralSubSys current in this.m_AllSubSys)
{
if (current is INetworkSetting)
{
((INetworkSetting)current).SetNetworkType(netType);
}
}
}
public FiledDisplayFormEditor(CollectionsModel model, NetWorkType type)
{
this.m_Model = model;
model.SiteColl.PropLabel = this;
model.TranceiverColl.PropLabel = this;
this.m_NetworkType = type;
this.m_GisDisplay = new GisDisPlay();
this.m_GisDisplay.SiteDisPlayPara = new DisplayPara(NetEntityType.Site);
this.m_GisDisplay.CellDisPlayPara = new DisplayPara(NetEntityType.Transceiver);
this.m_CellTypeDic = NECommon.GetCellTypeDic();
}
public GeneralProjectEntity(NetWorkType netType, string cfgFile)
{
this.m_ProjectSerializeData = new ProjectSerializeData();
this.ProjectSerializeData.NetType = netType;
this.m_CfgFile = cfgFile;
this.m_AppContext = new ApplicationContext();
this.m_AllSubSys = new List <IGeneralSubSys>();
this.m_SubSysConvert = new Dictionary <string, IDataConvert>();
this.ProjectIPLFile = string.Empty;
this.NeedPromptSave = false;
}
private void CreateNodeAndNodeManager(string treeNodeText, NetWorkType netType)
{
TreeNode node = new TreeNode(treeNodeText);
node.ContextMenuStrip = this.m_netTypeMenuStripDic[netType];
node.Tag = netType;
node.ImageKey = TrafficModelResource.TRAFFICMODEL_FOLDER;
node.SelectedImageKey = TrafficModelResource.TRAFFICMODEL_FOLDER;
this.m_ParentNode.Nodes.Add(node);
this.m_netTypeParentNodeDic.Add(netType, node);
TreeNodeManager manager = new TreeNodeManager(TrafficModelResource.TRAFFICMODEL_FOLDER_SERVICE, this.childcontextMenu, node);
this.m_netTypeTnManagerDic.Add(netType, manager);
}
public List<Terminal> FindTerminalList(NetWorkType netType)
{
List<Terminal> list = new List<Terminal>();
foreach (Terminal terminal in this.m_Model.TerminalManagement.TerminalList)
{
if (terminal.Technology == netType)
{
list.Add(terminal);
}
}
return list;
}
public List<Service> FindServiceListByNetType(NetWorkType netType)
{
List<Service> list = new List<Service>();
foreach (UnionPsService service in this.m_PsServiceManagement.FindUnionPsServiceList(netType))
{
list.Add(service);
}
foreach (UnionCsService service2 in this.m_CsServiceManagement.FindUnionCsServiceList(netType))
{
list.Add(service2);
}
return list;
}
//创建Group时调用
public IPredictionGroup CreateGroup(List<StudyTemplate> studyTemplateList, string groupName, int groupID, NetWorkType predictionType)
{
IPredictionGroup group = new LtePredictionGroup();
group.IsCoGroup = false;
group.Name = groupName;
group.GroupId = groupID;
group.PredictionType = predictionType;
foreach (StudyTemplate template in studyTemplateList)
{
group.StudyList.Add(this.CreateStudyByTemplate(template));
}
return group;
}
public static List <NetWorkType> ParseNetworkType(NetWorkType mulNetType)
{
List <NetWorkType> list = new List <NetWorkType>();
foreach (NetWorkType netWorkType in Enum.GetValues(typeof(NetWorkType)))
{
if ((netWorkType & mulNetType) == netWorkType)
{
list.Add(netWorkType);
}
}
return(list);
}
public void CopyFrom(Terminal terminal)
{
this.m_Antennas = terminal.Antennas;
this.m_Attenuation = terminal.Attenuation;
this.m_downLinkBearer = terminal.DownLinkBearer;
this.m_Gain = terminal.Gain;
this.m_Name = terminal.Name;
this.m_NetTerminalList.Clear();
this.NetTerminalList.AddRange(terminal.NetTerminalList);
this.m_Reception = terminal.Reception;
this.m_Technology = terminal.Technology;
this.m_upLinkBearer = terminal.UpLinkBearer;
}
public void AddNetworkLegend(ISimulationGroup group, NetWorkType nt)
{
try
{
this.DeleteNetworkLegend(group, nt);
StyleStruct ss = group.Style.StyleDic[nt][0];
string title = this.GetGroupNetworkTitle(group, nt);
this.m_LegendManagement.Add("Simulation", this.GetStyleStructLegend(title, ss).ToArray());
}
catch (Exception exception)
{
WriteLog.Logger.Error("Add Legend Failed", exception);
}
}
private List<IACell> GetCellListByNetWorkType(List<Transceiver> allTransceiver, NetWorkType predictionType)
{
List<IACell> list = new List<IACell>();
foreach (Transceiver transceiver in allTransceiver)
{
foreach (IACell cell in transceiver.Cells)
{
if (cell.NetType == predictionType)
{
list.Add(cell);
}
}
}
return list;
}
public bool CanChangUPlanworkType(NetWorkType netType)
{
bool result;
foreach (IGeneralSubSys current in this.m_AllSubSys)
{
if (current is INetworkSetting)
{
if (!((INetworkSetting)current).CanChangUPlanworkType(netType))
{
result = false;
return(result);
}
}
}
result = true;
return(result);
}
private async void Current_NetworkStatusChanged(object sender)
{
if (CoreDispatcher == null)
{
NetWorkType = NetworkManager.Current.Network;
}
else
{
if (CoreDispatcher.HasThreadAccess)
{
NetWorkType = NetworkManager.Current.Network;
}
else
{
await CoreDispatcher.RunAsync(CoreDispatcherPriority.Normal,
() => NetWorkType = NetworkManager.Current.Network);
}
}
}
public NetBase(float _HeartTime, float _DisConnTime, NetWorkType _type)
{
type = _type;
DisConnTime = _DisConnTime * 1000;
HeartTime = _HeartTime * 1000;
lock (msg_obj) { }
switch (type)
{
case NetWorkType.Kcp:
//kcp = new KCPClient(this);
//kcp.DisConnectEvent += DisConn;
//kcp.ConnectResultEvent += ConnectBack;
break;
case NetWorkType.Tcp:
tcp = new TcpClient(this);
tcp.DisConnectEvent += DisConn;
tcp.ConnectResultEvent += ConnectBack;
break;
}
}
public NetBase(string _ip, int _port, float _HeartTime, float _DisConnTime, NetWorkType _type)
{
ip = _ip;
port = _port;
type = _type;
DisConnTime = _DisConnTime * 1000;
HeartTime = _HeartTime * 1000;
lock (msg_obj) { }
switch (type)
{
case NetWorkType.Kcp:
kcp = new KCPClient(this);
kcp.DisConnectEvent += DisConn;
kcp.ConnectResultEvent += ConnectBack;
break;
case NetWorkType.Tcp:
tcp = new TcpClient(this);
tcp.DisConnectEvent += DisConn;
tcp.ConnectResultEvent += ConnectBack;
break;
}
}
public void InitNetWork(string ip, int port, float _HeartTime, float _DisConnTime, NetWorkType type)
{
EndNetWork();
network = new NetBase(ip, port, _HeartTime, _DisConnTime, type);
}
private AppDomain()
{
NetWorkType = NetworkManager.Current.Network;
NetworkManager.Current.NetworkStatusChanged += Current_NetworkStatusChanged;
}
