init

.gitignore

+*.ncf
+*.csv
+*.o
+.*.swp
+*.log

Makefile

+# Repast HPC Manual Build Makefile
+
+# VARIABLES (Supply values for these; for definitions and examples, see INSTALL)
+CXX=mpicxx
+CXXLD=mpicxx
+BOOST_INCLUDE_DIR=/home/songxinkai/sfw/Boost/Boost_1.61/include
+BOOST_LIB_DIR=/home/songxinkai/sfw/Boost/Boost_1.61/lib
+BOOST_INFIX=-mt
+NETCDF_INCLUDE_DIR=/home/songxinkai/sfw/NetCDF/include
+NETCDF_LIB_DIR=/home/songxinkai/sfw/NetCDF/lib
+NETCDF_CXX_INCLUDE_DIR=/home/songxinkai/sfw/NetCDF-cxx/include
+NETCDF_CXX_LIB_DIR=/home/songxinkai/sfw/NetCDF-cxx/lib
+CURL_INCLUDE_DIR=/home/songxinkai/sfw/CURL/include
+CURL_LIB_DIR=/home/songxinkai/sfw/CURL/lib
+INSTALL_DIR=/home/songxinkai/sfw/rpg
+
+REPAST_HPC_INCLUDE_DIR=${HOME}/sfw/repast_hpc-2.3.0/include
+REPAST_HPC_LIB_DIR=${HOME}/sfw/repast_hpc-2.3.0/lib
+RELOGO_INCLUDE_DIR=${HOME}/sfw/repast_hpc-2.3.0/include
+RELOGO_LIB_DIR=${HOME}/sfw/repast_hpc-2.3.0/lib
+
+# change to true to build static libraries
+STATIC=false
+
+# DIRECTORIES
+ZOMBIE_DIR=./zombie
+
+# DERIVED VARIABLES (Do not modify)
+I_REPAST_HPC=-I$(REPAST_HPC_INCLUDE_DIR)
+L_REPAST_HPC=-L$(REPAST_HPC_LIB_DIR)
+l_REPAST_HPC=-lrepast_hpc-2.3
+I_RELOGO=-I$(RELOGO_INCLUDE_DIR)
+L_RELOGO=-L$(RELOGO_LIB_DIR)
+l_RELOGO=-lrelogo-2.3
+I_BOOST=-I$(BOOST_INCLUDE_DIR)
+L_BOOST=-L$(BOOST_LIB_DIR)
+l_BOOST=-lboost_mpi$(BOOST_INFIX) -lboost_serialization$(BOOST_INFIX) -lboost_system$(BOOST_INFIX) -lboost_filesystem$(BOOST_INFIX)
+I_NETCDF=-I$(NETCDF_INCLUDE_DIR) -I$(NETCDF_CXX_INCLUDE_DIR)
+L_NETCDF=-L$(NETCDF_LIB_DIR) -L$(NETCDF_CXX_LIB_DIR)
+l_NETCDF=-lnetcdf_c++ -lnetcdf
+I_CURL=-I$(CURL_INCLUDE_DIR)
+L_CURL=-L$(CURL_LIB_DIR)
+l_CURL=-lcurl
+
+RPATHS :=
+ifneq ($(NETCDF_LIB_DIR),)
+  RPATHS += -Wl,-rpath -Wl,$(NETCDF_LIB_DIR)
+endif
+
+ifneq ($(NETCDF_CXX_LIB_DIR),)
+  RPATHS += -Wl,-rpath -Wl,$(NETCDF_CXX_LIB_DIR)
+endif
+
+ifneq ($(BOOST_LIB_DIR),)
+  RPATHS += -Wl,-rpath -Wl,$(BOOST_LIB_DIR)
+endif
+RELOGO_RPATHS = $(RPATHS) -Wl,-rpath -Wl,$(RELOGO_LIB_DIR)
+
+# These are are set in the modules included below
+ZOMBIE_SRC :=
+ZOMBIE_SRC += $(ZOMBIE_DIR)/main.cpp
+ZOMBIE_SRC += $(ZOMBIE_DIR)/Zombie.cpp
+ZOMBIE_SRC += $(ZOMBIE_DIR)/Human.cpp
+ZOMBIE_SRC += $(ZOMBIE_DIR)/ZombieObserver.cpp
+ZOMBIE_SRC += $(ZOMBIE_DIR)/InfectionSum.cpp
+
+# OBJECT FILES
+ZOMBIE_OBJECTS=$(patsubst %.cpp,%.o,$(ZOMBIE_SRC))
+
+LIB_I_FLAGS = $(I_BOOST) $(I_NETCDF) $(I_CURL) $(I_REPAST_HPC) $(I_RELOGO)
+LIB_L_FLAGS = $(L_BOOST) $(L_NETCDF) $(L_CURL) $(L_REPAST_HPC) $(L_RELOGO)
+LIB_l_FLAGS = $(l_BOOST) $(l_NETCDF) $(l_CURL) $(l_REPAST_HPC) $(l_RELOGO)
+# need to able to set this to empty for the static compile
+OUTPUT_FLAG = -o
+
+EXE_FLAG =
+ifeq ($(STATIC), true)
+	DYN_FLAG =
+	LIB_EXT = a
+	LIB_CXXLD = ar rcs
+	LIB_L_FLAGS =
+	LIB_l_FLAGS =
+	
+	RELOGO_L_FLAGS =
+	RELOGO_l_FLAGS =
+	OUTPUT_FLAG =
+	RPATHS =
+	RELOGO_RPATHS =
+	EXE_FLAG = -static
+else
+	UNAME := $(shell uname)
+	ifeq ($(UNAME), Darwin)
+		DYN_FLAG = -dynamiclib
+		LIB_EXT = dylib
+	endif
+endif
+
+# TARGETS
+ZOMBIE_EXE=$(INSTALL_DIR)/bin/zombie/zombie_model
+
+# Default rule makes everything
+.PHONY : all
+all: zombie_model
+$(ZOMBIE_EXE): $(ZOMBIE_OBJECTS)
+	mkdir -p $(INSTALL_DIR)/bin/zombie
+	cp $(ZOMBIE_DIR)/config.props $(INSTALL_DIR)/bin/zombie/
+	cp $(ZOMBIE_DIR)/model.props $(INSTALL_DIR)/bin/zombie/
+	$(CXXLD) $(EXE_FLAG) -o $(ZOMBIE_EXE) $(ZOMBIE_OBJECTS) $(I_RELOGO) $(L_RELOGO) $(LIB_I_FLAGS) $(LIB_L_FLAGS) $(LIB_l_FLAGS) $(RELOGO_RPATHS)
+
+# User-friendly names
+.PHONY : zombie_model
+zombie_model: $(ZOMBIE_EXE)
+
+
+# Cleanup
+.PHONY : zombie_clean
+zombie_clean :
+	rm -f $(ZOMBIE_DIR)/*.o
+	rm -rf ${INSTALL_DIR}/bin
+
+.PHONY : clean
+clean: zombie_clean
+
+# Object files are built from cpp files
+%.o:
+	$(CXX) -fPIC -std=c++11 -c $(LIB_I_FLAGS) -g0 -O3 -o $@ $*.cpp
+
+# Cancel implicit rule for name with no suffix, to avoid confusing output:
+%: %.o

bin/zombie/config.props

+
+# DEBUG, INFO, WARN, ERROR
+logger.root = INFO, R, stdout      
+logger.repast.system = DEBUG, R, stdout
+ 
+appender.R = RollingFileAppender
+appender.R.MaxBackupIndex =  1
+appender.R.File = ./logs/repast.log
+appender.R.MaxFileSize=200
+

bin/zombie/model.props

+#random.seed = 1284067381
+stop.at = 100
+
+# per process
+human.count = 500;
+zombie.count = 5;
+
+# world definition props
+min.x = -100
+min.y = -100
+max.x = 99
+max.y = 99 
+grid.buffer = 2
+
+# these must multiply to total number of processes
+proc.per.x = 2
+proc.per.y = 2
+
+# named random number distributions
+distribution.zombie_move = int_uniform, 0, 2
+
+

machinefile

+10.200.16.129
+10.200.16.130
+10.200.16.131
+10.200.16.132
+10.200.16.133
+10.200.16.134
+10.200.16.135
+10.200.16.136

zombie/AgentPackage.h

+/*
+*Repast for High Performance Computing (Repast HPC)
+*
+*   Copyright (c) 2010 Argonne National Laboratory
+*   All rights reserved.
+*  
+*   Redistribution and use in source and binary forms, with 
+*   or without modification, are permitted provided that the following 
+*   conditions are met:
+*  
+*  	 Redistributions of source code must retain the above copyright notice,
+*  	 this list of conditions and the following disclaimer.
+*  
+*  	 Redistributions in binary form must reproduce the above copyright notice,
+*  	 this list of conditions and the following disclaimer in the documentation
+*  	 and/or other materials provided with the distribution.
+*  
+*  	 Neither the name of the Argonne National Laboratory nor the names of its
+*     contributors may be used to endorse or promote products derived from
+*     this software without specific prior written permission.
+*  
+*   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+*   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+*   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+*   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+*   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+*   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+*   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+*   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+ * AgentContent.h
+ *
+ *  Created on: Sep 2, 2010
+ *      Author: nick
+ */
+
+#ifndef AGENTPACKAGE_H
+#define AGENTPACKAGE_H
+
+#include "repast_hpc/AgentId.h"
+
+struct AgentPackage {
+
+	template<class Archive>
+	void serialize(Archive& ar, const unsigned int version) {
+		ar & id;
+		ar & proc;
+		ar & type;
+		ar & currentProc;
+
+		ar & infectionTime;
+		ar & infected;
+	}
+
+	int id, proc, type, currentProc;
+
+	int infectionTime;
+	bool infected;
+
+	repast::AgentId getId() const {
+		return repast::AgentId(id, proc, type, currentProc);
+	}
+};
+
+
+
+#endif /* AGENTCONTENT_H_ */

zombie/Human.cpp

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * Human.cpp
+ *
+ *  Created on: Sep 1, 2010
+ *      Author: nick
+ */
+
+#include "relogo/AgentSet.h"
+#include "relogo/Patch.h"
+#include "ZombieObserver.h"
+
+#include "repast_hpc/RepastProcess.h"
+
+#include "Human.h"
+#include "Zombie.h"
+
+using namespace repast::relogo;
+using namespace repast;
+
+struct CountZombiesOnPatch {
+	double operator()(const Patch* patch) const {
+		AgentSet<Zombie> set;
+		patch->turtlesOn(set);
+		return set.size();
+	}
+};
+
+void Human::infect() {
+	if (!_infected) {
+		_infected = true;
+		((ZombieObserver*) _observer)->incrementInfectionCount();
+	}
+}
+
+void Human::step() {
+	// if human is now dead we can't move it because
+	// it will be removed from the sim and the synchronization
+	// mechanism cannot move it.
+	bool alive = true;
+	if (_infected) {
+		_infectionTime++;
+		if (_infectionTime == 50) {
+			// should be safe to die here as nothing else
+			// will need this object, so OK to delete it
+			_observer->hatch<Zombie> (this);
+			die();
+			alive = false;
+		}
+	}
+	
+	if (alive) {
+		// are there any zombies in the ngh
+		AgentSet<Patch> nghs = patchHere<Patch> ()->neighbors<Patch> ();
+		Patch* winningPatch = nghs.minOneOf(CountZombiesOnPatch());
+		face(winningPatch);
+		double distanceToMove = 1.5; // For non-toroidal worlds, need to check to make sure move is not out of bounds
+		while((_observer->patchAtOffset(location(), heading(), distanceToMove) == 0) && (distanceToMove > 0)) distanceToMove--;
+	//  if(distanceToMove > 0) move(distanceToMove);
+	}
+}
+

zombie/Human.h

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * Human.h
+ *
+ *  Created on: Sep 1, 2010
+ *      Author: nick
+ */
+
+#ifndef HUMAN_H_
+#define HUMAN_H_
+
+#include "relogo/Turtle.h"
+#include "AgentPackage.h"
+
+class Human : public repast::relogo::Turtle {
+
+private:
+	bool _infected;
+	int _infectionTime;
+
+public:
+	Human(repast::AgentId id, repast::relogo::Observer* obs): repast::relogo::Turtle(id, obs), _infected(false), _infectionTime(0) {}
+	Human(repast::AgentId id, repast::relogo::Observer* obs, const AgentPackage& package): repast::relogo::Turtle(id, obs), _infected(package.infected),
+			_infectionTime(package.infectionTime) {}
+	virtual ~Human() {}
+
+	void step();
+
+	void infect();
+
+	bool infected() const {
+		return _infected;
+	}
+
+	int infectionTime() const {
+		return _infectionTime;
+	}
+
+  void set(bool infected, int infectionTime){
+    _infected = infected;
+    _infectionTime = infectionTime;
+  }
+};
+
+#endif /* HUMAN_H_ */

zombie/InfectionSum.cpp

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * InfectionSum.cpp
+ *
+ *  Created on: Oct 13, 2010
+ *      Author: nick
+ */
+
+#include "InfectionSum.h"
+#include "ZombieObserver.h"
+
+InfectionSum::InfectionSum(ZombieObserver* zobs) : obs(zobs){}
+
+InfectionSum::~InfectionSum() {}
+
+int InfectionSum::getData() {
+	return obs->infectionCount();
+}

zombie/InfectionSum.h

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * InfectionSum.h
+ *
+ *  Created on: Oct 13, 2010
+ *      Author: nick
+ */
+
+#ifndef INFECTIONSUM_H_
+#define INFECTIONSUM_H_
+
+#include "repast_hpc/TDataSource.h"
+
+class ZombieObserver;
+
+class InfectionSum: public repast::TDataSource<int> {
+
+private:
+	ZombieObserver* obs;
+
+public:
+	InfectionSum(ZombieObserver* zobs);
+	virtual ~InfectionSum();
+
+	int getData();
+};
+
+#endif /* INFECTIONSUM_H_ */

zombie/Zombie.cpp

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * Zombie.cpp
+ *
+ *  Created on: Sep 1, 2010
+ *      Author: nick
+ */
+
+#include "Zombie.h"
+#include "Human.h"
+
+#include "relogo/AgentSet.h"
+#include "relogo/Patch.h"
+
+using namespace repast::relogo;
+using namespace repast;
+
+struct CountHumansOnPatch {
+	double operator()(const Patch* patch) const {
+		AgentSet<Human> set;
+		patch->turtlesOn(set);
+		return set.size();
+	}
+};
+
+void Zombie::step() {
+    Patch* p = patchHere<Patch>();
+    AgentSet<Patch> nghs = patchHere<Patch>()->neighbors<Patch>();
+    Patch* winningPatch = nghs.maxOneOf(CountHumansOnPatch());
+    face(winningPatch);
+    move(.5);
+
+    AgentSet<Human> humans;
+    turtlesHere(humans);
+
+    if (humans.size() > 0) {
+      Human* human = humans.oneOf();
+      infect(human);
+    }
+  }
+
+  void Zombie::infect(Human* human) {
+    human->infect();
+    //_observer->createLink(this*, human, "Infection");
+}

zombie/Zombie.h

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * Zombie.h
+ *
+ *  Created on: Sep 1, 2010
+ *      Author: nick
+ */
+
+#ifndef ZOMBIE_H_
+#define ZOMBIE_H_
+
+#include "relogo/Turtle.h"
+
+class Human;
+
+class Zombie : public repast::relogo::Turtle {
+public:
+	Zombie(repast::AgentId id, repast::relogo::Observer* obs) : repast::relogo::Turtle(id, obs) {}
+	virtual ~Zombie() {}
+
+	void step();
+	void infect(Human* human);
+};
+
+#endif /* ZOMBIE_H_ */

zombie/ZombieObserver.cpp

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * ZombieObserver.cpp
+ *
+ *  Created on: Sep 1, 2010
+ *      Author: nick
+ */
+#include <sstream>
+#include <iostream>
+
+#include "relogo/RandomMove.h"
+#include "relogo/grid_types.h"
+#include "relogo/Patch.h"
+#include "repast_hpc/AgentRequest.h"
+#include "repast_hpc/SVDataSet.h"
+#include "repast_hpc/SVDataSetBuilder.h"
+
+#ifndef _WIN32
+#include "repast_hpc/NCDataSetBuilder.h"
+#endif
+
+#include "ZombieObserver.h"
+#include "Human.h"
+#include "Zombie.h"
+#include "InfectionSum.h"
+
+using namespace std;
+using namespace repast;
+using namespace relogo;
+
+const string HUMAN_COUNT_PROP = "human.count";
+const string ZOMBIE_COUNT_PROP = "zombie.count";
+
+void ZombieObserver::go() {
+  if (_rank == 0) {
+    Log4CL::instance()->get_logger("root").log(INFO, "TICK BEGINS: " + boost::lexical_cast<string>(RepastProcess::instance()->getScheduleRunner().currentTick()));
+  }
+  synchronize<AgentPackage>(*this, *this, *this, RepastProcess::USE_LAST_OR_USE_CURRENT);
+
+  AgentSet<Zombie> zombies;
+  get(zombies);
+  zombies.ask(&Zombie::step);
+
+  // AgentId id(0,0,2);
+  // Zombie* z = who<Zombie>(id);
+
+  AgentSet<Human> humans;
+  get(humans);
+  humans.ask(&Human::step);
+
+  if (_rank == 0) {
+    cout << "rank: " << _rank << ", zombies.count: " << zombies.count() 
+         << ", humans.count: " << humans.count() 
+          << endl;
+    cout << "zombies: " << endl;
+    for (int i = 0; i < zombies.size(); ++i){
+      cout << "(" << zombies.at(i)->xCor() << ", " << zombies.at(i)->yCor() 
+            << ") " << endl;
+            //<< ") infected: " << zombies.at(i)->infected() << endl;
+    }
+    Log4CL::instance()->get_logger("root").log(INFO, "TICK ENDS: " + boost::lexical_cast<string>(RepastProcess::instance()->getScheduleRunner().currentTick()));
+  }
+}
+
+void ZombieObserver::setup(Properties& props) {
+  //	Observer::setup(props); // No longer need to call this (SimRunner calls _setup, which calls this after all initialization is done)
+  repast::Timer initTimer;
+  initTimer.start();
+
+  int humanCount = strToInt(props.getProperty(HUMAN_COUNT_PROP));
+  humanType = create<Human> (humanCount);
+
+  int zombieCount = strToInt(props.getProperty(ZOMBIE_COUNT_PROP));
+  zombieType = create<Zombie> (zombieCount);
+
+  AgentSet<Human> humans;
+  get(humans);
+  humans.apply(RandomMove(this));
+
+  AgentSet<Zombie> zombies;
+  get(zombies);
+  zombies.apply(RandomMove(this));
+
+	SVDataSetBuilder svbuilder("./output/data.csv", ",", repast::RepastProcess::instance()->getScheduleRunner().schedule());
+	InfectionSum* iSum = new InfectionSum(this);
+	svbuilder.addDataSource(repast::createSVDataSource("number_infected", iSum, std::plus<int>()));
+	addDataSet(svbuilder.createDataSet());
+
+
+#ifndef _WIN32
+	// no netcdf under windows
+	NCDataSetBuilder builder("./output/data.ncf", RepastProcess::instance()->getScheduleRunner().schedule());
+	InfectionSum* infectionSum = new InfectionSum(this);
+	builder.addDataSource(repast::createNCDataSource("number_infected", infectionSum, std::plus<int>()));
+	addDataSet(builder.createDataSet());
+#endif
+
+	long double t = initTimer.stop();
+	std::stringstream ss;
+	ss << t;
+	props.putProperty("init.time", ss.str());
+}
+
+RelogoAgent* ZombieObserver::createAgent(const AgentPackage& content) {
+	if (content.type == zombieType) {
+		return new Zombie(content.getId(), this);
+	} else if (content.type == humanType) {
+		return new Human(content.getId(), this, content);
+	} else {
+		// it's a patch.
+		return new Patch(content.getId(), this);
+	}
+}
+
+void ZombieObserver::provideContent(const repast::AgentRequest& request, std::vector<AgentPackage>& out) {
+	const vector<AgentId>& ids = request.requestedAgents();
+	for (int i = 0, n = ids.size(); i < n; i++) {
+		AgentId id = ids[i];
+		AgentPackage content = { id.id(), id.startingRank(), id.agentType(), id.currentRank(), 0, false };
+		if (id.agentType() == humanType) {
+			Human* human = who<Human> (id);
+			content.infected = human->infected();
+			content.infectionTime = human->infectionTime();
+		}
+		out.push_back(content);
+	}
+}
+
+void ZombieObserver::provideContent(RelogoAgent* agent, std::vector<AgentPackage>& out) {
+	AgentId id = agent->getId();
+	AgentPackage content = { id.id(), id.startingRank(), id.agentType(), id.currentRank(), 0, false };
+	if (id.agentType() == humanType) {
+		Human* human = static_cast<Human*> (agent);
+		content.infected = human->infected();
+		content.infectionTime = human->infectionTime();
+	}
+	out.push_back(content);
+}
+
+void ZombieObserver::createAgents(std::vector<AgentPackage>& contents, std::vector<RelogoAgent*>& out) {
+	for (size_t i = 0, n = contents.size(); i < n; ++i) {
+		AgentPackage content = contents[i];
+		if (content.type == zombieType) {
+			out.push_back(new Zombie(content.getId(), this));
+		} else if (content.type == humanType) {
+			out.push_back(new Human(content.getId(), this, content));
+		} else {
+			// it's a patch.
+			out.push_back(new Patch(content.getId(), this));
+		}
+	}
+}
+
+void ZombieObserver::updateAgent(AgentPackage package){
+  repast::AgentId id(package.id, package.proc, package.type);
+  if (id.agentType() == humanType) {
+    Human * human = who<Human> (id);
+    human->set(package.infected, package.infectionTime);
+  }
+}

zombie/ZombieObserver.h

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * ZombieObserver.h
+ *
+ *  Created on: Sep 1, 2010
+ *      Author: nick
+ */
+
+#ifndef ZOMBIEOBSERVER_H_
+#define ZOMBIEOBSERVER_H_
+
+#include "relogo/Observer.h"
+#include "repast_hpc/AgentRequest.h"
+#include "repast_hpc/Properties.h"
+
+#include "AgentPackage.h"
+
+class ZombieObserver : public repast::relogo::Observer {
+
+private:
+	repast::Properties props;
+	int zombieType, humanType;
+	int _infectionCount;
+
+public:
+	ZombieObserver() : _infectionCount(0) {}
+	virtual ~ZombieObserver() {}
+
+	void go();
+	virtual void setup(repast::Properties& props); // NOTE: 'virtual' needed by some compilers
+
+	// create and provide for agents moving between processes
+	repast::relogo::RelogoAgent* createAgent(const AgentPackage& content);
+	void provideContent(const repast::AgentRequest& request, std::vector<AgentPackage>& out);
+
+	// create and provide for buffer sync
+	void createAgents(std::vector<AgentPackage>& content, std::vector<repast::relogo::RelogoAgent*>& out);
+	void provideContent(repast::relogo::RelogoAgent* agent, std::vector<AgentPackage>& out);
+
+	void updateAgent(AgentPackage package);
+
+	void incrementInfectionCount() {
+		_infectionCount++;
+	}
+
+	int infectionCount() const {
+		return _infectionCount;
+	}
+};
+
+#endif /* ZOMBIEOBSERVER_H_ */

zombie/config.props

+
+# DEBUG, INFO, WARN, ERROR
+logger.root = INFO, R, stdout      
+logger.repast.system = DEBUG, R, stdout
+ 
+appender.R = RollingFileAppender
+appender.R.MaxBackupIndex =  1
+appender.R.File = ./logs/repast.log
+appender.R.MaxFileSize=200
+

zombie/main.cpp

+/*
+ *   Repast for High Performance Computing (Repast HPC)
+ *
+ *   Copyright (c) 2010 Argonne National Laboratory
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with
+ *   or without modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *     Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *
+ *     Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *     Neither the name of the Argonne National Laboratory nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ *   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE TRUSTEES OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ */
+
+#include <boost/mpi.hpp>
+
+#include "repast_hpc/io.h"
+#include "repast_hpc/RepastProcess.h"
+#include "relogo/SimulationRunner.h"
+#include "relogo/Patch.h"
+//#include "repast_hpc/initialize_random.h"
+
+#include "ZombieObserver.h"
+
+using namespace repast;
+using namespace relogo;
+
+
+void usage() {
+	std::cerr << "usage: X  string string" << std::endl;
+	std::cerr << "  first string: string is the path to the Repast HPC \n\tconfiguration properties file"
+			<< std::endl;
+	std::cerr << "  second string: string is the path to the model properties file" << std::endl;
+}
+
+void runZombies(std::string propsFile, int argc, char ** argv) {
+  boost::mpi::communicator world;
+	Properties props(propsFile, argc, argv, &world);
+
+  std::string time;
+  repast::timestamp(time);
+  props.putProperty("date_time.run", time);
+
+  props.putProperty("process.count", world.size());
+
+	SimulationRunner runner(&world);
+
+	if(world.rank() == 0) std::cout << " Starting... " << std::endl;
+	repast::Timer timer;
+	timer.start();
+	runner.run<ZombieObserver, Patch>(props);
+
+  props.putProperty("run.time", timer.stop());
+
+
+  if(world.rank() == 0){
+    std::vector<std::string> keysToWrite;
+    keysToWrite.push_back("run.number");
+    keysToWrite.push_back("date_time.run");
+    keysToWrite.push_back("process.count");
+    keysToWrite.push_back("random.seed");
+    keysToWrite.push_back("human.count");
+    keysToWrite.push_back("zombie.count");
+    keysToWrite.push_back("min.x");
+    keysToWrite.push_back("min.y");
+    keysToWrite.push_back("max.x");
+    keysToWrite.push_back("max.y");
+    keysToWrite.push_back("proc.per.x");
+    keysToWrite.push_back("proc.per.y");
+    keysToWrite.push_back("grid.buffer");
+    keysToWrite.push_back("init.time");
+    keysToWrite.push_back("stop.at");
+    keysToWrite.push_back("run.time");
+    props.log("root");
+    props.writeToSVFile("Zombies.csv", keysToWrite);
+  }
+
+
+
+}
+
+int main(int argc, char **argv) {
+	boost::mpi::environment env(argc, argv);
+	std::string config, props;
+	boost::mpi::communicator world;
+
+	if (argc >= 3) {
+		config = argv[1];
+		props = argv[2];
+
+	} else {
+		if (world.rank() == 0) usage();
+		return 0;
+	}
+
+	if (config.size() > 0 && props.size() > 0) {
+		RepastProcess::init(config, &world);
+		runZombies(props, argc, argv);
+	} else {
+		if (world.rank() == 0) usage();
+		return 0;
+	}
+
+	RepastProcess::instance()->done();
+	return 0;
+}
+

zombie/model.props

+#random.seed = 1284067381
+stop.at = 100
+
+# per process
+human.count = 500;
+zombie.count = 5;
+
+# world definition props
+min.x = -100
+min.y = -100
+max.x = 99
+max.y = 99 
+grid.buffer = 2
+
+# these must multiply to total number of processes
+proc.per.x = 2
+proc.per.y = 2
+
+# named random number distributions
+distribution.zombie_move = int_uniform, 0, 2
+
+

zombie/module.mk

+DIR := zombie
+
+ZOMBIE_SRC += $(DIR)/main.cpp
+ZOMBIE_SRC += $(DIR)/Zombie.cpp
+ZOMBIE_SRC += $(DIR)/Human.cpp
+ZOMBIE_SRC += $(DIR)/ZombieObserver.cpp
+ZOMBIE_SRC += $(DIR)/InfectionSum.cpp