Giới thiệu thực tế về OptimalGrid – Phần IV

// 
Gói OPCEden.java com.ibm.almaden.smartgrid.apps.eden; 
/ * 
** Tài liệu được cấp phép - Tài sản của IBM 
** 
** (C) BẢN QUYỀN IBM Corp. 2002 Mọi quyền được bảo lưu. 
** 
** Quyền hạn chế của người dùng của chính phủ Hoa Kỳ - Sử dụng, sao chép hoặc 
** tiết lộ bị hạn chế bởi Lịch trình GSA ADP 
** Hợp đồng với IBM Corp. 
** 
* / 
import java.io.Serializable; 
nhập java.util.ArrayList; 
nhập java.util.Iterator; 
nhập java.util.Random; 
nhập java.util.Vector; 
nhập com.ibm.almaden.smartgrid.AppUtilsGeneric; 
nhập com.ibm.almaden.smartgrid.Coferences; 
nhập com.ibm.almaden.smartgrid.EntityAbstract;
nhập com.ibm.almaden.smartgrid.OPCAbstract; 
nhập com.ibm.almaden.smartgrid.AppUtilsAbstract; 
nhập com.ibm.almaden.smartgrid.VppAbstract; 
nhập com.ibm.almaden.smartgrid.util.ConfigFile; 
nhập com.ibm.almaden.smartgrid.util.Debug;
/ ** cho đầu ra xml 
* / 
import org.jdom.Element; 
// |||||||||||||||||||||||||||||||||||||||||||||||||| |||||||||||||||||||||||| 
// || Lớp OPCEden (Ô gốc có vấn đề || 
// ||||||||||||||||||||||||||||||||||||||| 
/ * * 
** 
** 
** OPCEden.java xác định "Tế bào Vấn đề Ban đầu" 
* cho mô hình Eden về sự phát triển của vi khuẩn. 
** 
* OPCEden mở rộng OPCAbstract 
* 
* Mô hình Eden OPC mô tả một vùng không gian đại diện cho 
bề mặt của đĩa petri . Nếu có thể chứa các đối tượng thực thể như vi khuẩn, 
chất dinh dưỡng, v.v. Nó cũng có thể có các đặc tính cục bộ ảnh hưởng đến hành vi 
(tốc độ sinh sản) của vi khuẩn. Các phương pháp bắt buộc, nhân giống (),
và localInteraction (), xác định cách các thực thể này tái tạo và 
lây lan sang các OPC lân cận dựa trên các thực thể và thuộc tính 
khác có thể có mặt. 
* 
** Ô bài toán ban đầu là một đơn vị bài toán "nguyên tử" - phần 
** của bài toán đại diện cho một đơn vị tính toán (như một 
** diện tích (2D) hoặc một thể tích (3D) tiếp xúc với một số bên ngoài 
* * tương tác theo thời gian). OPC tương tác với 
** hàng xóm của họ - chia sẻ thông tin để tạo ra một 
phép tính ** lớn hơn (bức tranh lớn) . Tuy nhiên, điều đó có nghĩa là OPC phải giao tiếp 
** trạng thái của nó với các OPC lân cận vào cuối mỗi "lát thời gian" 
** để tương tác láng giềng có thể được tính toán để tạo ra 
** khung tiếp theo.
** 
* Người tạo ra một bài toán tính toán thiết lập bộ sưu tập 
** OPC và cũng tách các nhóm OPC thành các phân vùng có thể tính toán được 
** (được gọi là Phân vùng vấn đề có thể thay đổi - VPP) được cấp cho 
** tác nhân tính toán, tốt, tính toán. Mỗi VPP (chủ yếu chạy trên 
một máy riêng biệt) phải giao tiếp các cạnh của nó với các VPP khác 
** 
* 
* Các OPC được lưu trữ trong các bộ sưu tập OPCCollection của lớp. 
** 
** 
* Để có hình ảnh thể hiện cách OPC phù hợp với 
VPP, hãy tham khảo {@link OPCAbstract}. 
* 
* 
* Mô hình Eden về sự phát triển của vi khuẩn. 
* 
* Trong mô hình Eden, mỗi OPC đại diện cho một ô có thể
* chứa một thực thể đại diện cho một trong 3 loại vi khuẩn; A, B hoặc C. 
* Trong trường hợp này, phương thức tương tác khiến A ăn B, B ăn C, 
* và C ăn A. 
* Ngoài ra, các thực thể có thể truyền cho các đối tượng lân cận của chúng với 
* một xác suất xác định mà nó sẽ là ăn bởi hàng xóm hoặc 
* ăn thịt người hàng xóm. 
* 
* 
** @author> A HREF = "mailto: [email protected]"/ A < 
** @author> A HREF = "mailto: [email protected]"/ A < 
** @author> A HREF = "mailto: [email protected]"/ A < 
** @version $ Bản sửa đổi: 1,3 $ $ Ngày: 2003/05/22 15:19:32 $ 
** @see com.ibm.almaden.smartgrid.OPCAbstract 
** @see com.ibm.almaden.smartgrid .OPCCollection 
** @see EntityEden 
** @see EntityAbstract 
* / 
// |||||||||||||||||||||||||||||||||| ||||||||||||||||||||||||||||||||||||||| // 
public class OPCEden mở rộng OPCAbstract thực hiện Serializable, Cloneable { 
static final long serialVersionUID = -41318389852439458L; 
static private final String _className = "OPCEden";
/ ************************************************* ************************* 
** OPCEden ** (trống) 
********* / 
/ ** 
** Lớp này OPCEden tạo ra một ô vấn đề ban đầu 
** để tính toán con mồi của kẻ săn mồi 
************************************* ************************************** 
* / 
public OPCEden () { 
super._occupants = null ; 
super._properties = null; 
} 
/ ************************************************ ************************** 
** processNeighbor ** 
******************* / 
/ ** 
* Với một OPC lân cận, hãy xem liệu có thực thể nào từ nó 
* sẽ truyền sang danh sách Người chiếm đóng cho OPC hiện tại 
*
* @param OPCNeighbor OPC là hàng xóm của OPC hiện tại 
* @param newOccupants ArrayList chứa các thực thể cạnh tranh hiện tại. 
* @param vpp_ Vpp chính. 
* @param iteration_ Số lần lặp hiện tại 
* @return void 
************************************** ************************************* 
* / 
private void processNeighbor (OPCEden OPCNeighbor, ArrayList newOccupants, 
VppAbstract vpp_, int iteration_, Ngẫu nhiên rnd_) { 
ArrayList hisOccupants = OPCNeighbor.getOccupants (); 
if (hisOccupants.size ()> 0) { 
int numOccupants = hisOccupants.size (); 
// xem xét tất cả những người cư ngụ của anh ấy 
cho (int j = 0; j<numoccupants; j++)="" {<br="">// lấy người ở dưới dạng thực thể 
EntityEden ea = (EntityEden) (hisOccupants.get (j)); 
// tạo xác suất lan truyền cho thực thể này 
double prob = getPropagationProb (ea, rnd_); 
if ((prob> ea.getPropProb ()) && \ 
(entityNotPresent (ea, newOccupants)))) { 
// nếu vượt quá ngưỡng xác suất và chưa phải là đối tượng cư trú 
EntityAbstract child = ea.getChild (); 
// vpp _._ valueMonitor.accumulateValueData \ 
(iteration_, child.getEntityID (), 1); 
// thêm vào danh sách mới của Occupants 
newOccupants.add (child); 
} 
} // cho j (num chiếm) 
} // kích thước> 0 
} 
/ ******************************** ******************************************
** getPropagationProb ** 
******************* / 
/ ** 
* Tạo xác suất lan truyền cho một số thực thể 
* dựa trên thực thể và thuộc tính của OPC này. 
* 
* Nếu OPC không có bất kỳ thuộc tính nào, thì 
xác suất ngẫu nhiên * được tạo tiếp theo được trả về. Nếu không, đối tượng 
Thuộc tính được lấy * từ tập hợp Thuộc tính và xác suất được tính dựa trên 
* dựa trên Thuộc tính. 
* Phương pháp (hơi không thực tế) này giả định rằng Thuộc tính đầu tiên chứa 
* một giá trị xác suất. Nếu ID thuộc tính khớp với \ 
ID thực thể (loại vi khuẩn) 
* thì giá trị này được thêm vào xác suất lan truyền được tính toán, 
* nếu không thì giá trị này sẽ bị trừ. 
*
* @param ea entityAbstract 
* @param rnd_ Random rnd_ 
* @ xác suất quay trở lại 
*********************************** **************************************** 
* / 
private double getPropagationProb (entityAbstract ea, Random rnd_) { 
double prob = rnd_.nextDouble ();
int entityID = ea.getentityID (); 
int numProps = 0; 
if (_properties! = null) { 
numProps = _properties.size (); 
if (numProps> 0) { 
PropertyEden p = (PropertyEden) _properties.get (0); 
if (p.getPropertyID () == entityID) { 
prob + = p.getProbability (); 
if (prob> 1.0) 
prob = 1.0; 
} else { 
prob - = p.getProbability (); 
nếu (prob <0.0) 
prob = 0.0; 
} 
} 
} 
trả về prob; 
} 
/ ** 
********************************************** ********************************* 
* cloneOPC () 
* phương thức bắt buộc để trả về một bản sao của OPC với một 
* bản sao của các đối tượng đó trong OPC này có thể được sửa đổi.
* 
* 
* Mô hình Eden yêu cầu chúng tôi chỉ tạo một bản sao sâu của những người cư trú 
* 
* Các biến sau không bắt buộc 
* trong phương pháp sao chép mô hình eden này nhưng có thể được yêu cầu 
* trong các ứng dụng đồng bộ khác 
* 
* newOPC._properties = new Vector () ; 
* newOPC._loc = this._loc; 
* newOPC._index = this._index; = 
* newOPC._edgeCollectionID = this._edgeCollectionID; 
* newOPC._edgeIndex = this._edgeIndex; 
* 
* @ quay lại bản sao của OPC này 
** / 
public OPCAbstract cloneOPC () { 
OPCEden newOPC = null; 
thử { 
newOPC = (OPCEden) this.clone (); 
} catch (CloneNotSupportedException cns) {
Debug.error (_className + "cloneOPC", "Lỗi", cns); 
} 
// tạo bản sao sâu của ArrayList. 
ArrayList newOccupants = new ArrayList (); 
ArrayList oldOccupants = this.getOccupants (); 
if (oldOccupants == null || oldOccupants.size () == 0) { 
newOPC.setOccupants (null); 
} else { 
newOccupants.addAll (oldOccupants); 
newOPC.setOccupants (mớiOccupants); 
} // không null 
trả về newOPC; 
}; 
/ ************************************************* ************************* 
** entityNotPresent ** 
******************** * / 
/ ** 
* Kiểm tra đối tượng EntityEden so với danh sách Mảng và trả về "true" nếu
* không có EntityEden cùng kiểu đã có trong ArrayList 
* 
* 
* @param ea_ Một thực thể trừu tượng 
* @param a_ Một ArrayList gồm các thực thể (các đối tượng EntityEden) 
* 
* @return true nếu loại thực thể này KHÔNG hiện diện. 
* 
*
************************************************** ************************* 
* / 
public boolean entityNotPresent (EntityAbstract ea_, ArrayList a_) { 
// trước tiên hãy đảm bảo rằng đối tượng lớp này chưa có mặt 
int classID = ea_.getEntityID (); 
int numEnts = a_.size (); 
for (int i = 0; i <numEnts; i ++) { 
EntityAbstract obj = (EntityAbstract) a_.get (i); 
int classID2 = obj.getEntityID (); 
// nếu đã ở đó, punt 
if (classID == classID2) return false; 
} 
// else 
trả về true; 
} 
/ ************************************************ ************************** 
** initFromXML () ** 
***************** ** / 
/ **
* Phương thức này chỉ cần thiết nếu chúng ta đã định nghĩa biến phiên bản mới 
* cho lớp này. Tham khảo EntityEden để biết ví dụ về mã hóa bắt buộc. 
* 
************************************************* ************************** 
* / 
// public void initFromXML (Element OPCElement_) { 
// super.initCommonSubsetFromXML (OPCElement_); 
//} // getXML () 
/ ***************************************** ********************************* 
** getXML () ** 
********** ********* / 
/ ** 
* Phương thức này chỉ cần thiết nếu chúng ta đã định nghĩa biến phiên bản mới 
* cho lớp này. Tham khảo EntityEden để biết ví dụ về mã hóa bắt buộc. 
************************************************** *************************
* / 
// public Phần tử getXML () { 
// Phần tử OPCElement = super.getXmlElement (); 
// trả về OPCElement; 
//} // getXML () 
/ ***************************************** ********************************* 
** toString ** 
************ ** / 
/ ** 
** Cung cấp đầu ra gỡ lỗi tốt. Thao tác này sẽ nhận đầu ra từ phương thức 
* OPCAbstract.toString () và sau đó thêm một số thông tin 
* về người sử dụng và thuộc tính. 
** 
** Chuỗi @return đại diện cho các giá trị trong đối tượng 
************************************ *************************************** 
* / 
public String toString () { 
// Đặt mọi thứ vào một bộ đệm chuỗi trước (chọn kích thước phù hợp),
// và sau đó chuyển thành một chuỗi ở cuối. 
// 
StringBuffer sb = new StringBuffer (64); 
sb.append (super.toString ()); 
sb.append ("OPCEden:"); 
if (_occupants! = null) { 
sb.append ("# Occupants =" + _ Occupants.size ()); 
} 
if (_properties! = null) { 
sb.append ("#Properties =" + _ property.size ()); 
} 
return sb.toString (); 
} // end toString () 
} // Lớp OPCEden</numoccupants;>

/ ************************************************* ************************* 
** tuyên truyền ** 
************** / 
/ ** 
* 
* Tất cả các OPC đều giao tiếp với hàng xóm (cục bộ hoặc từ xa) 
* broadcast () để OPCEden xác định những thực thể nào 
* hiện diện tại các trang lân cận và sao chép chúng, thêm bất kỳ 
* loại thực thể mới nào vào trang web này. Không bao giờ có nhiều hơn 
* nhiều hơn một loại thực thể được đại diện. Bước này được thực hiện 
* trước khi các thực thể được phép cạnh tranh (ăn thịt lẫn nhau) 
* được thực hiện sau bằng phương thức localInteraction. 
* Theo phương pháp đó, chúng ta biết vi khuẩn lây lan sang 
* OPCs nào - và những vi khuẩn nào sống sót. 
*
* Lưu ý rằng danh sách "người ở" mới được trả về nhưng không được 
* lưu trữ lại vào OPC. Điều này là để khi 
* OPC tiếp theo được xử lý và họ nhìn lại tôi (với tư cách là hàng xóm) 
* họ sẽ thấy tình trạng cư trú cũ của tôi. 
* 
* Nói chung, trong phương thức truyền (), bạn chỉ muốn 
* thao tác với danh sách những người ở và không sửa đổi OPC 
* hoặc các thuộc tính. Sử dụng phương thức localInteraction () để 
* thực hiện các thay đổi đối với OPC và Thuộc tính. 
* 
* @param collectionIndex_ Chỉ mục vào mảng 
* OPCCollections cho 
* OPCCollection mà OPC này thuộc về. 
* @param vpp_ VPP chính * @param lặp_ Số 
lần lặp hiện tại (chu kỳ)
* @param rnd_ Trình tạo số ngẫu nhiên. 
* 
* @return Đã cập nhật bộ sưu tập người cư ngụ (thực thể) cho OPC này. 
* 
************************************************* ************************** 
* / 
công khai ArrayList được đồng bộ hóa phổ biến (int collectionIndex_, \ 
VppAbstract vpp_, int iteration_, Random rnd_) { 
String methodName = _className + ".propagate"; 
ArrayList newOccupants = new ArrayList (); 
ArrayList oldOccupants = super.getOccupants (); 
// bỏ ghi chú sau nếu chúng ta muốn sử dụng lớp appUtils. 
// AppUtilsGeneric appUtil = \ 
(AppUtilsGeneric) OPCAbstract.getAppUtils (); 
if (oldOccupants.size ()> 0) 
newOccupants.addAll (oldOccupants);
// || ============================================== || 
// || = Nhận tất cả những người hàng xóm (dù là địa phương hay từ xa ========= || 
// || ========================== ==================== || 
ArrayList tempArray = this.getAllOPCNeighbors (collectionIndex_, vpp_); 
Iterator iter = tempArray.iterator (); 
while (iter.hasNext () ) { 
// lấy phần tử tập hợp 
OPCEden OPCNeighbor = (OPCEden) iter.next (); 
// truyền các thực thể hàng xóm tới newOccupants processNeighbor 
(OPCNeighbor, newOccupants, vpp_, iteration_, rnd_); 
} // while hasNext 
// trả về danh sách những người cư ngụ 
trả về newOccupants; 
} // truyền ()

/ ************************************************* ************************* 
** localInteraction ** 
******************** ** / 
/ ** 
* Sau khi chúng tôi tìm hiểu từ việc tuyên truyền loài vi khuẩn nào 
* đang cạnh tranh để sống trên trang web này trong bước thời gian tiếp theo, chúng tôi sẽ xem xét 
* qua tất cả những người cư ngụ cạnh tranh của OPCEden này 
* và xem liệu đối với từng người cư trú, có một kẻ săn mồi 
* ăn thịt người cư ngụ. 
* 
* Sau đó chúng tôi vòng qua những người cư ngụ một lần nữa và loại bỏ 
vi khuẩn * đã chết . Sau đó, chúng tôi gọi phương thức updateCount cập nhật 
* thông tin về số lượng thực thể cho biểu đồ. 
* 
* Cuối cùng, chúng tôi lưu trữ danh sách hiện tại của những người cư ngụ vào OPC. 
* 
*
* @param vpp_ Vpp chính. 
* @param iteration_ Số lần lặp hiện tại 
* @param Occupants_ ArrayList của các thực thể mới cho OPC này 
* Đây là ArrayList của những cư dân được trả về bởi 
phương thức truyền. Chúng tôi bắt buộc phải lưu trữ nó vào OPC. 
* 
* @return void 
* 
******************************************** ******************************* 
* / 
public sync void localInteraction (VppAbstract vpp_, \ 
int iteration_, ArrayList chiếm_ ) { 
String methodName = _className + ".localInteraction"; 
// có người cư ngụ không? 
if ((Occupants_! = null) && (! Occupants_.isEmpty ())) { 
// có, sau đó lặp qua chúng 
for (int i = 0; i<occupants_.size(); i++)="" {<br="">for (int j = 0; j <Occupants_.size (); j ++) { 
if (i == j) continue; 
EntityEden obj1 = (EntityEden) Occupants_.get (i); 
EntityEden obj2 = (EntityEden) Occupants_.get (j); 
// obj2._foodID chứa loại thực phẩm mà obj2 ăn. 
// vì vậy nếu nó khớp với EntityID cho obj1, thì obj2 ăn obj1. 
if (obj2.isAlive () && (obj2.getFoodID () == obj1.getEntityID ())) { 
// vâng, thì obj1 đã chết 
obj1.setAlive (false); 
} 
} // cho j 
} // cho i. Vòng lặp đầu tiên kiểm tra các động vật ăn thịt 
// cuối cùng lặp lại một lần nữa và loại bỏ các đối tượng đã chết 
đối với (Iterator iter = Occupants_.iterator (); iter.hasNext ();) { 
EntityEden obj1 = (EntityEden) iter.next (); 
if (! obj1.isAlive ()) {
iter.remove (); 
} 
} // lặp lại. Vòng lặp thứ hai loại bỏ những người chiếm dụng đã chết 
} // kết thúc nếu không phải null hoặc rỗng 
// cập nhật đang chạy tổng số các thực thể 
super.updateCounter (vpp_, iteration_, Occupants_); 
// cập nhật OPCAbstract 
super.setOccupants (Occupants_); 
} // localInteraction ()</occupants_.size();>