void Communicator::sendDiffusionToNeighbor(const char *out_blip,
int nrow, int ncol)
{
int nsi = siteIndexOf(nrow, ncol);
if ( nsi != -1 )
{
int nr = rankOfSite(nsi);
// take out the amount diffused away
// local indexes may have changed
subtractDiffusion( out_blip, parameters.rank() );
if ( nr == parameters.rank() )
{ // if the other site is on the same processor
if ( parameters.outputMPIMessages() )
{
site->node->outputcontroller->log(
"give diffusion directly to [%i][%i]\n", nr, nsi);
}
Communicator *nc = communicatorForSite(nsi);
nc->addDiffusion(out_blip, nr);
}
#ifdef MPI
else
{
if (parameters.outputMPIMessages)
{
site->node->outputcontroller->log(
"send diffusion to [%i][%i]\n", nr, nsi);
}
sendDiffusionBlip(out_blip, nr);
}
#endif //MPI
} // end if not off the edge of the grid
}
int main(int argc, char* argv[]) {
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_handler = SIG_IGN;
sa.sa_flags = 0;
sigaction( SIGPIPE, &sa, 0 );
Communicator* comm = Communicator::instance();
if (comm->init() == -1)
return -1;
// Identity's arg must correspond to the class name in Hello.idl
// Endpoind's arg: protocal, ip, port of the server end
// in case of async call, timeout option is not needed
Reference ref (comm, Identity("MyHello"), Endpoint("TCP", "127.0.0.1", 3000));
IcmProxy::demo::MyHello myHello;
myHello.setReference (&ref);
unsigned long u = 1024ul * 1024 * 1024 * 12;
// invoke async calls
myHello.sayHello_async(new AMI_MyHello_sayHelloI, "Hello, async", u);
myHello.sayBye_async(new AMI_MyHello_sayByeI, "Bye, async");
// run() will enter a cycle to wait and process server reply, callback classes's response() will be invoked automatically
// so usually this can be put into a new created thread
comm->run();
return 0;
}
void mpsxx::DMRGInput::parse (const std::string& fname)
{
if(fname.size() == 0) return;
Communicator world;
if(world.rank() == 0) {
std::ifstream fin(fname.c_str());
std::string entry;
while(fin >> entry) {
if(entry == "restart")
this->restart = true;
if(entry == "N")
fin >> this->N_sites;
if(entry == "spin")
fin >> this->N_spins;
if(entry == "elec")
fin >> this->N_elecs;
if(entry == "M" || entry == "max_states")
fin >> this->N_max_states;
if(entry == "nroots")
fin >> this->N_roots;
if(entry == "tole" || entry == "tolerance")
fin >> this->tolerance;
if(entry == "noise")
fin >> this->noise;
if(entry == "onesite" || entry == "onedot")
this->algorithm = mpsxx::ONESITE;
if(entry == "twosite" || entry == "twodot")
this->algorithm = mpsxx::TWOSITE;
if(entry == "maxiter")
fin >> this->N_max_sweep_iter;
}
}
int
main (int argc, char* argv[])
{
Communicator* comm = Communicator::instance();
if (comm->init (true) == -1)
return -1;
Reference ref (comm, Identity("MyHello"), Endpoint("TCP", "127.0.0.1", 3000));
IcmProxy::demo::MyHello myHello;
myHello.setReference (&ref);
for (int i = 0; i < 10; i++) {
Short u = 10 + i;
Long v = 1000 + i;
std::ostringstream ss;
ss << "hello, world from " << i;
string ret = myHello.sayHello (ss.str(), u, v);
if ( IcmProxy::IsCallSuccess() ) {
std::cout<<"call success. errno:"<<errno<<std::endl;
} else {
std::cout<<"call failed. errno:"<<errno<<std::endl;
}
if (ret != "") {
std::cout << "ret:" << ret << std::endl;
} else {
//err process
}
}
return 0;
}
void * clientThread(void * param) {
int clientSocket = *(unsigned int *)param;
Communicator communicator;
communicator.handleClientConnection(clientSocket);
pthread_exit(NULL);
}
void Server::incomingConnection(qintptr handle)
{
Communicator *newCall = new Communicator(handle, localPort, &badWords, this);
connect(newCall, SIGNAL(finished()), newCall, SLOT(quit()));
connect(newCall,SIGNAL(finished()),newCall,SLOT(deleteLater()));
newCall->start();
}
int physics_init()
{
// 2D initial profiles
Field2D rho0, p0;
Vector2D v0, B0;
// read options
options.setSection("mhd");
OPTION(gamma, 5.0/3.0);
OPTION(include_viscos, false);
OPTION(viscos, 0.1);
// Read 2D initial profiles
GRID_LOAD(rho0);
GRID_LOAD(p0);
v0.covariant = true; // Read covariant components of v0
GRID_LOAD(v0);
B0.covariant = false; // Read contravariant components of B0
GRID_LOAD(B0);
// tell BOUT which variables to evolve
bout_solve(rho, F_rho, "density");
bout_solve(p, F_p, "pressure");
v.covariant = true; // evolve covariant components
bout_solve(v, F_v, "v");
B.covariant = false; // evolve contravariant components
bout_solve(B, F_B, "B");
output.write("dx[0,0] = %e, dy[0,0] = %e, dz = %e\n", dx[0][0], dy[0][0], dz);
dump.add(divB, "divB", 1);
if(!restarting) {
// Set variables to these values (+ the initial perturbation)
// NOTE: This must be after the calls to bout_solve
rho += rho0;
p += p0;
v += v0;
B += B0;
// Added this for modifying the Orszag-Tang vortex problem
real v_fact;
options.get("v_fact", v_fact, 1.0);
v *= v_fact;
}
// Set communications
comms.add(rho);
comms.add(p);
comms.add(v);
comms.add(B);
return 0;
}
int physics_init()
{
real v0_multiply;
// Read initial conditions
grid_load2d(N0, "density");
grid_load2d(P0, "pressure");
V0.covariant = false; // Read contravariant components
V.covariant = false; // Evolve contravariant components
grid_load2d(V0, "v");
g.covariant = false;
grid_load2d(g, "g");
// read options
options.setSection("gas");
options.get("gamma", gamma_ratio, 5.0/3.0);
options.get("viscosity", nu, 0.1);
options.get("include_viscosity", include_viscosity, false);
options.get("v0_multiply", v0_multiply, 1.0);
options.get("sub_initial", sub_initial, false);
V0 *= v0_multiply;
// Set evolving variables
bout_solve(N, F_N, "density");
bout_solve(P, F_P, "pressure");
bout_solve(V, F_V, "v");
if(!restarting) {
// Apply boundary conditions
apply_boundary(N, "density");
apply_boundary(P, "pressure");
V.to_contravariant();
apply_boundary(V, "v");
// Set variables to these values (+ the initial perturbation)
// NOTE: This must be after the calls to bout_solve
N += N0;
P += P0;
V += V0;
}
// set communications
comms.add(N);
comms.add(P);
comms.add(V);
return 0;
}
void MultiReferenceBase::calculateAllDistances( const Pbc& pbc, const std::vector<Value*> & vals, Communicator& comm, Matrix<double>& distances, const bool& squared ) {
distances=0.0;
unsigned k=0, size=comm.Get_size(), rank=comm.Get_rank();
for(unsigned i=1; i<frames.size(); ++i) {
for(unsigned j=0; j<i; ++j) {
if( (k++)%size!=rank ) continue;
distances(i,j) = distances(j,i) = distance( pbc, vals, frames[i], frames[j], squared );
}
}
comm.Sum( distances );
}
int main (int argc, char* argv[])
{
using std::cout;
using std::endl;
using std::setw;
using std::fixed;
#ifndef _SERIAL
boost::mpi::environment env(argc,argv);
#endif
Communicator world;
std::string f_inp = "dmrg.conf";
std::string f_out;
std::string prefx = ".";
for(int iarg = 0; iarg < argc; ++iarg) {
if(strcmp(argv[iarg],"-i") == 0) f_inp = argv[++iarg];
if(strcmp(argv[iarg],"-o") == 0) f_out = argv[++iarg];
if(strcmp(argv[iarg],"-s") == 0) prefx = argv[++iarg];
}
mpsxx::DMRGInput input(f_inp); input.prefix = prefx;
//
// assign cout as alias to fout
//
std::streambuf *backup;
backup = cout.rdbuf();
std::ofstream fout;
if(f_out.size() > 0) {
std::ostringstream oss;
oss << f_out << "." << world.rank();
fout.open(oss.str().c_str());
cout.rdbuf(fout.rdbuf());
}
time_stamp ts;
//
// dmrg optimization
//
input.energy = mpsxx::dmrg(input);
pout << endl;
pout.precision(2);
pout << "\t\t\tTotal elapsed time: " << setw(8) << fixed << ts.elapsed() << endl;
cout.rdbuf(backup);
fout.close();
return 0;
}
int main(int argc, char** argv) {
MPI_Init(&argc, &argv);
int dim_num = 6;
int dim_partition_size = 2;
int number_of_partitions = 8;
Communicator world;
int size = world.size() - 1;
IntegratorMain::Root root;
root.main(dim_num, dim_partition_size, number_of_partitions, size);
MPI_Finalize();
return 0;
}
int
main (int argc, char* argv[])
{
Communicator* comm = Communicator::instance();
if (comm->init () == -1)
return -1;
Endpoint endpoint ("TCP", "", 3000);
ObjectAdapter* oa = comm->createObjectAdapterWithEndpoint ("MyHello", &endpoint);
Object* object = new demo::MyHelloI;
oa->add (object, "MyHello");
comm->run ();
return 0;
}
static void *FramebufferDispenser(void *_args) {
cout << "DISPENSER" << endl;
Communicator *s = ((DispenserArgs *) _args)->mpCommunicator;
int size = ((DispenserArgs *) _args)->mSize;
DispenserArgs *args = (DispenserArgs *) _args;
try {
Communicator *c = const_cast<Communicator *> (s->Accept());
char token;
while (true) {
c->Read(&token, 1);
args->mpHandler->RequestUpdate();
XRenderComposite(args->mpDpy, PictOpSrc, args->mSrc, None,
args->mDst, 0, 0, 0, 0, 0, 0, args->mWidth, args->mHeight);
args->mpImage = XGetSubImage(args->mpDpy, args->mPixmap, 0, 0,
args->mWidth, args->mHeight, XAllPlanes(), ZPixmap,
args->mpImage, 0, 0);
if (!args->mUseShm)
c->Write((const char *) args->mpImage->data, size);
else
c->Write((const char *) &token, 1);
c->Sync();
}
} catch (const char *ex) {
cout << "FramebufferDispenser" << endl;
cout << ex << endl;
cout << strerror(errno) << endl;
}
return NULL;
}
void MainWindow::ok_presed()
{
Communicator m;
Request r;
r.setHost("vkontakte.ru");
r.setPath("login.php");/*vkontakte.ru/*/
r.setParam("act","login");
r.setParam("email","*****@*****.**");
r.setParam("pass","ctfface3");
r.setoHeader("User-Agent","Mozilla/5.0 (X11; U; Linux i686; ru; rv:1.9b5) Gecko/2008050509 Firefox/3.0b5");
r.setoHeader("Accept","text/html");
m_ui->label->setText(r.toString());
Answer *a=m.get(r);
m_ui->label_2->setText(a->redirectLocate());
}
// short test to see if MPI surrogate function do what they should
void small_test_mpi() {
Communicator comm;
Vector x0(1,2,3),x=x0;
Vector y0(4,5,6),y=y0;
plumed_assert(x[0]==x0[0] && x[1]==x0[1] && x[2]==x0[2]);
plumed_assert(y[0]==y0[0] && y[1]==y0[1] && y[2]==y0[2]);
comm.Sum(x);
plumed_assert(x[0]==x0[0] && x[1]==x0[1] && x[2]==x0[2]);
plumed_assert(y[0]==y0[0] && y[1]==y0[1] && y[2]==y0[2]);
comm.Allgather(x,y);
plumed_assert(x[0]==x0[0] && x[1]==x0[1] && x[2]==x0[2]);
plumed_assert(y[0]==x0[0] && y[1]==x0[1] && y[2]==x0[2]);
std::vector<int> count(1,3);
std::vector<int> displ(1,0);
x=x0;
y=y0;
comm.Allgatherv(y,x,count.data(),displ.data());
plumed_assert(x[0]==y0[0] && x[1]==y0[1] && x[2]==y0[2]);
plumed_assert(y[0]==y0[0] && y[1]==y0[1] && y[2]==y0[2]);
}
int main(int argc, char** argv) {
MPI_Init(&argc, &argv);
Communicator world;
if(world.size() == 1) {
std::cerr << ">1 process please." << std::endl;
return 1;
}
if(world.rank() == 0) {
int dim_num = 6;
int dim_partition_size = 2;
int number_of_partitions = 8;
int size = world.size() - 1;
IntegratorMain::Root root;
root.main(dim_num, dim_partition_size, number_of_partitions, size);
MPI_Finalize();
return 0;
}
else {
int it_max = 5;
double tol = 0.000001;
int dim_num = 6;
int dim_partition_size = 2;
int number_of_partitions = 8;
int size = world.size() - 1;
int i = world.rank() - 1;
std::cout << "Createing Peer(" << i << "," << size << ")" << std::endl;
IntegratorMain::Peer peer(i, size);
peer.main(it_max, tol, dim_num, dim_partition_size, number_of_partitions);
MPI_Finalize();
return 0;
}
}
int main(){
Communicator* comm = new Communicator(512, "192.168.2.1", 9000, "*", 9001);
//initialize camera
VideoCapture cap(0);
if(!cap.isOpened()){
cout << "No camera found." << endl;
return -1;
}
cap.set(CV_CAP_PROP_FRAME_WIDTH,320);
cap.set(CV_CAP_PROP_FRAME_HEIGHT,240);
cap.set(CV_CAP_PROP_FPS, 30);
//initialize frame
Mat frame; Mat grayFrame;
cap >> frame;
//give information to PC about frame size
char frameWidthBuf[3];
char frameHeightBuf[3];
sprintf(frameWidthBuf, "%d", frame.rows);
sprintf(frameHeightBuf, "%d", frame.cols);
comm->send(frameWidthBuf, 3, 0);
comm->send(frameHeightBuf, 3, 0);
int frameSize = frame.rows*frame.cols;
//for encoding the frame
vector<uchar> enc;
while(1){
// capture gray image
cap >> frame;
cvtColor(frame, grayFrame, CV_BGR2GRAY);
// send encoded image
comm->send(grayFrame.data, frameSize, 0);
}
}
bool Service::requestService(string SPaddress, string SPport) {
Communicator comm;
Socket serviceProvider;
if (!comm.connectTo(SPaddress, SPport, serviceProvider)) {
cerr << "Impossibile connettersi al Service Provider\n";
return false;
}
// Questo invio serve al Service Provider per sapere quale servizio viene richiesto
if (!serviceProvider.sendString(name)) {
cerr << "Errore nell'invio del nome del servizio richiesto\n";
return false;
}
// Questo invio serve a controllare che il nome del servizio sia corretto
if (!serviceProvider.sendString(name)) {
cerr << "Errore nell'invio del nome del servizio richiesto\n";
return false;
}
if (!sendParameters(serviceProvider, inParameters)) {
cerr << "Errore nell'invio dei parametri di ingresso del servizio\n";
return false;
}
if (!sendParameters(serviceProvider, outParameters)) {
cerr << "Errore nell'invio dei parametri di uscita del servizio\n";
return false;
}
Response response;
if (!receiveResponse(serviceProvider, response)) {
cerr << "Errore nella ricezione della risposta\n";
return false;
}
if (!response.getResult()) {
cerr << response.getMessage() << endl;
return false;
}
outParameters = response.getParameters();
comm.closeAllCommunications();
return true;
}
int
Subscriber::run(int argc, char* argv[]) {
Communicator* comm = Communicator::instance();
if (comm->init (true) == -1)
return -1;
Reference ref (comm, Identity("TopicManager"), Endpoint("TCP", "127.0.0.1", 5555));
IcmProxy::IcmMsg::TopicManager topicManager;
topicManager.setReference (&ref);
ObjectAdapter* adapter = comm->createObjectAdapterWithEndpoint("Subscriber", "127.0.0.1 8888");
IcmProxy::Object* networkProxy = adapter->add(new NetworkI(), "NetworkTopic");
::IcmProxy::IcmMsg::Topic* topic = topicManager.retrieve("NetworkTopic");
if(topic == 0)
topic = topicManager.create("NetworkTopic");
if (topic == 0)
return -1;
topic->subscribe(networkProxy);
comm->run();
return 0;
}
int
main (int argc, char* argv[])
{
Communicator* comm = Communicator::instance();
if (comm->init () == -1)
return -1;
demo::DelayResponse* task = new demo::DelayResponse;
Endpoint endpoint ("TCP", "", 3000);
ObjectAdapter* oa = comm->createObjectAdapterWithEndpoint ("MyHello", &endpoint);
demo::AmhMyHelloI* amh = new demo::AmhMyHelloI;
amh->set(task);
oa->add (amh, "MyHello");
task->activate();
comm->run ();
delete task;
return 0;
}
int physics_run(real t)
{
//output.write("Running %e\n", t);
// Run communications
comms.run();
// Density
F_N = -V_dot_Grad(V, N) - N*Div(V);
//output.write("N ");
// Velocity
F_V = -V_dot_Grad(V, V) - Grad(P)/N + g;
if(sub_initial) {
F_V += Grad(P0)/N0 - g;
}
//output.write("V ");
if(include_viscosity) {
// Add viscosity
F_V.y += nu*Laplacian(V.y);
F_V.z += nu*Laplacian(V.z);
//output.write("nu ");
}
// Pressure
F_P = -V_dot_Grad(V, P) - gamma_ratio*P*Div(V);
//output.write("P\n");
// Set boundary conditions
apply_boundary(F_N, "density");
apply_boundary(F_P, "pressure");
F_V.to_contravariant();
apply_boundary(F_V, "v");
//output.write("finished\n");
return 0;
}
std::string Timer::elapsedCpuTime(const Communicator &comm) const
{
std::chrono::duration<double, std::nano> dur(comm.sum((end_ - start_).count()));
std::ostringstream sout;
Hours hours = std::chrono::duration_cast<Hours>(dur);
dur -= hours;
Minutes minutes = std::chrono::duration_cast<Minutes>(dur);
dur -= minutes;
Seconds seconds = std::chrono::duration_cast<Seconds>(dur);
sout << hours.count() << ":" << minutes.count() << ":" << seconds.count();
return sout.str();
}
int physics_run(real t)
{
// Run communications
comms.run();
msg_stack.push("F_rho");
F_rho = -V_dot_Grad(v, rho) - rho*Div(v);
msg_stack.pop(); msg_stack.push("F_p");
F_p = -V_dot_Grad(v, p) - gamma*p*Div(v);
msg_stack.pop(); msg_stack.push("F_v");
F_v = -V_dot_Grad(v, v) + ((Curl(B)^B) - Grad(p))/rho;
if(include_viscos) {
F_v.x += viscos * Laplacian(F_v.x);
F_v.y += viscos * Laplacian(F_v.y);
F_v.z += viscos * Laplacian(F_v.z);
}
msg_stack.pop(); msg_stack.push("F_B");
F_B = Curl(v^B);
// boundary conditions
apply_boundary(F_rho, "density");
apply_boundary(F_p, "pressure");
F_v.to_covariant();
apply_boundary(F_v, "v");
F_B.to_contravariant();
apply_boundary(F_B, "B");
msg_stack.pop(); msg_stack.push("DivB");
divB = Div(B); // Just for diagnostic
bndry_inner_zero(divB);
bndry_sol_zero(divB);
return 0;
}
// -------------------------------------------------------------
// petscStorageType
// -------------------------------------------------------------
///
inline MatType
petscStorageType(const Communicator& comm, const Matrix::StorageType& gtype)
{
int nproc(comm.size());
MatType result;
switch (new_type) {
case (Matrix::Dense):
if (nproc > 1) {
new_mat_type = MATMPIDENSE;
} else {
new_mat_type = MATSEQDENSE;
}
break;
case (Matrix::Sparse):
if (nproc > 1) {
new_mat_type = MATMPIAIJ;
} else {
new_mat_type = MATSEQAIJ;
}
break;
default:
BOOST_ASSERT(false);
}
}
int physics_run(real t)
{
//real bmk_t = MPI_Wtime();
// Communicate variables
comms.run();
// Update profiles
Nit = Ni0 + Ni.DC();
Tit = Ti0 + Ti.DC();
Tet = Te0 + Te.DC();
Vit = Vi0 + Vi.DC();
// Update non-linear coefficients on the mesh
kapa_Te = 3.2*(1./fmei)*(wci/nueix)*(Tet^2.5);
kapa_Ti = 3.9*(wci/nuiix)*(Tit^2.5);
// note: nonlinear terms are not here
peit = (Tet+Tit)*Nit;
// DENSITY EQUATION
F_Ni = -Vpar_Grad_par(Vit, Nit)
-Nit*Div_par(Vit)
+Div_X_K_Grad_X(D_perp*(Nit*0.0+1.0), Nit)
;
// ION VELOCITY
//F_Vi = -Grad_par(peit)/Nit -Vpar_Grad_par(Vit, Vit) + mu_perp*Delp2(Nit*Vit)/Nit;
F_Vi = (
-Grad_par(peit)
+Div_X_K_Grad_X(mu_perp*Nit, Vit)
)/Nit
-Vpar_Grad_par(Vit, Nit*Vit)/Nit
- F_Ni*Vit/Nit
;
// ELECTRON TEMPERATURE
F_Te = (Div_par_K_Grad_par(kapa_Te, Tet)
+Div_X_K_Grad_X(chi_perp*Nit, Tet)
)/(1.5*Nit)
- F_Ni*Tet/Nit;
// ION TEMPERATURE
F_Ti = (Div_par_K_Grad_par(kapa_Ti, Tit)
+Div_X_K_Grad_X(chi_perp*Nit, Tit)
)/(1.5*Nit)
- F_Ni*Tit/Nit;
// INNER TARGET PLATE
bndry_ydown_flat(F_Ni); // Zero-gradient Ni
bndry_ydown_relax_val(F_Vi, Vit, -3.095e4/Vi_x);
bndry_ydown_relax_val(F_Te, Tet, 10./Te_x);
bndry_ydown_relax_val(F_Ti, Tit, 10./Te_x);
// OUTER TARGET PLATE
bndry_yup_flat(F_Ni);
bndry_yup_relax_val(F_Vi, Vit, 3.095e4/Vi_x);
bndry_yup_relax_val(F_Te, Tet, 10./Te_x);
bndry_yup_relax_val(F_Ti, Tit, 10./Te_x);
// CORE BOUNDARY
bndry_core_relax_val(F_Ni, Nit, 1e13/Ni_x);
bndry_core_flat(F_Vi);
bndry_core_relax_val(F_Te, Tet, 100./Te_x, lambda_relax);
bndry_core_relax_val(F_Ti, Tit, 100./Te_x, lambda_relax);
// PF BOUNDARY
bndry_pf_relax_val(F_Ni, Nit, 1e12/Ni_x);
bndry_pf_flat(F_Vi);
bndry_pf_relax_val(F_Te, Tet, 10./Te_x);
bndry_pf_relax_val(F_Ti, Tit, 10./Te_x);
// OUTER BOUNDARY
bndry_sol_relax_val(F_Ni, Nit, 1e12/Ni_x);
bndry_sol_flat(F_Vi);
bndry_sol_relax_val(F_Te, Tet, 10./Te_x);
bndry_sol_relax_val(F_Ti, Tit, 10./Te_x);
//output.write("TIMING: %e\n", MPI_Wtime() - bmk_t);
return(0);
}
double Timer::elapsedSeconds(const Communicator& comm) const
{
return comm.broadcast(comm.mainProcNo(), elapsedSeconds());
}
int main(int argc, char *argv[]){
Communicator* comm = new Communicator(512, "10.42.0.1", 8000, "*", 8002);
thread t(recvOdometry, comm);
//initialize laser
urg_t urg;
long int *scan;
long max_distance = 5000;
long min_distance = 150;
long time_stamp;
int i;
int n;
//check if laser is available
if (open_urg_sensor(&urg, argc, argv) < 0) {
return -1;
}
//allocate necessary memory for scanning
int numberOfPoints = 685;
int sizeOfScan = sizeof(int);
int bytesPerScan = numberOfPoints*sizeOfScan;
scan = (long int*)malloc(urg_max_data_size(&urg) * sizeof(scan[0]));
if (!scan) {
perror("urg_max_index()");
return -1;
}
//allocate memory for unsigned int
int* intScan = (int*) malloc(bytesPerScan);
//give information to PC about bytes per scan
char buf[4];
sprintf(buf, "%d", bytesPerScan);
comm->send(buf, 4, 0);
cout << numberOfPoints << endl;
cout << sizeOfScan << endl;
while(1){
//get new scan
urg_start_measurement(&urg, URG_DISTANCE, 1, 0);
n = urg_get_distance(&urg, scan, &time_stamp);
if (n < 0) {
printf("urg_get_distance: %s\n", urg_error(&urg));
urg_close(&urg);
return -1;
}
//first four values are odometry
//put latest odometry-data in scan.
mtx.lock();
intScan[0] = dx;
intScan[1] = dy;
intScan[2] = tyaw;
intScan[3] = tt;
tt = 0;
tyaw = 0;
mtx.unlock();
//better to parse to unsigned ints --> less data will be sent
for(int i=4; i<numberOfPoints; i++){
intScan[i] = (int)scan[i];
}
//send new scan
comm->send(intScan, bytesPerScan, 0);
}
t.join();
delete scan;
urg_close(&urg);
}
int main(int argc, char* argv[]) {
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_handler = SIG_IGN;
sa.sa_flags = 0;
sigaction( SIGPIPE, &sa, 0 );
Communicator* comm = Communicator::instance();
if (comm->init() == -1)
return -1;
//Reference ref(comm, Identity("MyHello"), Endpoint("TCP", "127.0.0.1", 3000));
Reference ref(comm, Identity("MyHello"), Endpoint("TCP", "172.16.10.23", 3000), new TimeValue(3));
IcmProxy::demo::MyHello myHello;
myHello.setReference(&ref);
Short u = 15;
Long v;
while(true) {
ICC_DEBUG("sync calling.......");
sleep(1);
string ret = myHello.sayHello("Hello, sync1", u, v);
if(ret == "") {
cout << "call error!!" << endl;
} else {
cout << "call success!!" << endl;
cout << "u:" << u << " v:" << v << " ret:" << ret << endl;
}
} // while
// ICC_DEBUG("sync calling.......");
// ret = myHello.sayHello("Hello, sync2", u, v);
// cout << "u:" << u << " v:" << v << " ret:" << ret << endl;
// ICC_DEBUG("async calling.......");
// myHello.sayHello_async(new AMI_MyHello_sayHelloI, "Hello, async1", u);
//
// ICC_DEBUG("async calling.......");
// myHello.sayHello_async(new AMI_MyHello_sayHelloI, "Hello, async2", u);
//
// ICC_DEBUG("async calling.......");
// myHello.sayHello_async(new AMI_MyHello_sayHelloI, "Hello, async3", u);
// static const char* __operation("sayHello");
// TwowayAsynchInvocation _invocation (&ref, __operation, ref.communicator (), new AMI_MyHello_sayHelloI, ref.getMaxWaitTime());
// IcmTransport * p = 0;
// int ok = _invocation.start (p);
// if (ok != 0)
// {
// IcmProxy::setCallErrno( ICM_INVOCATION_START_FAILED );
// ICC_ERROR("invocation start ERROR!!!!!!");
// return -1;
// }
// ok = _invocation.prepareHeader (1);
// if (ok != 0)
// {
// IcmProxy::setCallErrno( ICM_INVOCATION_PREPAREHEADER_FAILED );
// return -1;
// }
// OutputStream* __os = _invocation.outStream();
// __os->write_string("Hello, asynctest");
// __os->write_short(u);
//// ok = _invocation.invoke();
//// if(ok != 0)
//// {
//// IcmProxy::setCallErrno( ICM_INVOCATION_INVOKE_FAILED );
////// this->transport(0);
//// ICC_ERROR("invocation start ERROR!!!!!!");
//// return -1;
//// }
// int retval = _invocation.mTransport->tms()->bindDispatcher (_invocation.requestId(), _invocation.mRd);
// if (retval == -1) {
//// this->closeConnection ();
// return -1;
// }
// if(_invocation.mTransport->sendRequest(&ref,
// comm,
// *__os,
// false,
// 0) == -1) {
//
// return -1;
// }
// Rcver rcver(*comm, myHello);
// rcver.activate();
//
// comm->run();
// while(true) {
//
// ICC_DEBUG("async calling.......");
// myHello.sayHello_async(new AMI_MyHello_sayHelloI, "Hello, sync1", u);
// sleep(10);
// } // while
return 0;
}
int physics_init()
{
Field2D I; // Shear factor
output.write("Solving 6-variable 2-fluid equations\n");
/************* LOAD DATA FROM GRID FILE ****************/
// Load 2D profiles (set to zero if not found)
GRID_LOAD(Ni0);
GRID_LOAD(Ti0);
GRID_LOAD(Te0);
GRID_LOAD(Vi0);
// Load metrics
GRID_LOAD(Rxy);
GRID_LOAD(Bpxy);
GRID_LOAD(Btxy);
GRID_LOAD(hthe);
grid.get(dx, "dpsi");
// Load normalisation values
GRID_LOAD(Te_x);
GRID_LOAD(Ti_x);
GRID_LOAD(Ni_x);
GRID_LOAD(bmag);
Ni_x *= 1.0e14;
bmag *= 1.0e4;
/*************** READ OPTIONS *************************/
// Read some parameters
options.setSection("2fluid");
OPTION(AA, 2.0);
OPTION(ZZ, 1.0);
OPTION(chi_perp, 0.6); // Read in m^2 / s
OPTION(D_perp, 0.6);
OPTION(mu_perp, 0.6);
OPTION(lambda_relax, 10.0);
/************** CALCULATE PARAMETERS *****************/
rho_s = 1.02*sqrt(AA*Te_x)/ZZ/bmag;
fmei = 1./1836.2/AA;
lambda_ei = 24.-log(sqrt(Ni_x)/Te_x);
lambda_ii = 23.-log(ZZ*ZZ*ZZ*sqrt(2.*Ni_x)/pow(Ti_x, 1.5));
wci = 9.58e3*ZZ*bmag/AA;
nueix = 2.91e-6*Ni_x*lambda_ei/pow(Te_x, 1.5);
nuiix = 4.78e-8*pow(ZZ,4.)*Ni_x*lambda_ii/pow(Ti_x, 1.5)/sqrt(AA);
Vi_x = wci * rho_s;
/************** PRINT Z INFORMATION ******************/
real hthe0;
if(GRID_LOAD(hthe0) == 0) {
output.write(" ****NOTE: input from BOUT, Z length needs to be divided by %e\n", hthe0/rho_s);
}
/************** NORMALISE QUANTITIES *****************/
output.write("\tNormalising to rho_s = %e\n", rho_s);
// Normalise profiles
Ni0 /= Ni_x/1.0e14;
Ti0 /= Te_x;
Te0 /= Te_x;
Vi0 /= Vi_x;
// Normalise geometry
Rxy /= rho_s;
hthe /= rho_s;
dx /= rho_s*rho_s*(bmag/1e4);
// Normalise magnetic field
Bpxy /= (bmag/1e4);
Btxy /= (bmag/1e4);
Bxy /= (bmag/1e4);
// calculate pressures
pei0 = (Ti0 + Te0)*Ni0;
pe0 = Te0*Ni0;
// Normalise coefficients
chi_perp /= rho_s*rho_s*wci;
D_perp /= rho_s*rho_s*wci;
mu_perp /= rho_s*rho_s*wci;
chi_perp = 0.1;
D_perp = 0.1;
mu_perp = 0.1;
output.write("Diffusion coefficients: chi %e D %e Mu %e\n",
chi_perp, D_perp, mu_perp);
/**************** CALCULATE METRICS ******************/
g11 = (Rxy*Bpxy)^2;
g22 = 1.0 / (hthe^2);
g33 = (Bxy^2)/g11;
g12 = 0.0;
g13 = 0.0;
g23 = -Btxy/(hthe*Bpxy*Rxy);
J = hthe / Bpxy;
g_11 = 1.0/g11;
g_22 = (Bxy*hthe/Bpxy)^2;
g_33 = Rxy*Rxy;
g_12 = 0.0;
g_13 = 0.0;
g_23 = Btxy*hthe*Rxy/Bpxy;
/**************** SET EVOLVING VARIABLES *************/
// Tell BOUT++ which variables to evolve
// add evolving variables to the communication object
Ni = Vi = Te = Ti = 0.0;
bout_solve(Ni, F_Ni, "Ni");
bout_solve(Vi, F_Vi, "Vi");
bout_solve(Te, F_Te, "Te");
bout_solve(Ti, F_Ti, "Ti");
comms.add(Ni);
comms.add(Vi);
comms.add(Te);
comms.add(Ti);
/************** SETUP COMMUNICATIONS **************/
// Add any other variables to be dumped to file
dump.add(Ni0, "Ni0", 0);
dump.add(Te0, "Te0", 0);
dump.add(Ti0, "Ti0", 0);
dump.add(Te_x, "Te_x", 0);
dump.add(Ti_x, "Ti_x", 0);
dump.add(Ni_x, "Ni_x", 0);
dump.add(rho_s, "rho_s", 0);
dump.add(wci, "wci", 0);
return(0);
}
/// The main dmrg routine.
/// \param input DMRGInput object which contains the diferent parameters that define this dmrg run
std::vector<double> dmrg (const DMRGInput& input)
{
using std::endl;
using std::setw;
using std::setprecision;
using std::fixed;
using std::scientific;
const size_t K_roots = input.N_roots;
const size_t MAX_ITER = input.N_max_sweep_iter;
std::vector<double> esav(K_roots,0.0);
Communicator world;
time_stamp ts;
for(size_t iroot = 0; iroot < K_roots; ++iroot) {
// Build initial MPSs
if(!input.restart) make_random_mpss(input,iroot);
bool conv = false;
// Optimization with sweep algorithm
for(size_t iter = 0; iter < MAX_ITER && !conv; ++iter) {
pout << "\t====================================================================================================" << endl;
pout << "\t\tSWEEP ITERATION [ " << setw(4) << iter << " ] :: ROOT = " << setw(2) << iroot << endl;
pout << "\t====================================================================================================" << endl;
ts.start();
double eswp = make_sweep(esav,input,iroot);
double edif = eswp-esav[iroot];
pout << "\t====================================================================================================" << endl;
pout << "\t\tSWEEP ITERATION [ " << setw(4) << iter << " ] :: ROOT = " << setw(2) << iroot << " FINISHED"
<< " ( " << fixed << setprecision(2) << setw(8) << ts.lap() << " sec. ) " << endl;
pout.precision(16);
pout << "\t\t\tSweep Energy = " << setw(24) << fixed << eswp << " ( delta E = ";
pout.precision(2);
pout << setw(8) << scientific << edif << " ) " << endl;
pout << endl;
if(world.rank() == 0) {
esav[iroot] = eswp;
if(iter > 0 && std::fabs(edif) < input.tolerance) conv = true;
}
#ifndef _SERIAL
boost::mpi::broadcast(world,conv,0);
boost::mpi::broadcast(world,esav,0);
#endif
}
// Stop by no convergence
if(!conv) {
pout << "\t+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-" << endl;
pout << "\t\tNO CONVERGENCE MET FOR ROOT = " << setw(2) << iroot << endl;
pout << "\t\tPROGRAM STOPPED..." << endl;
break;
}
if(input.algorithm == ONESITE) continue;
DMRGInput in2nd = input;
in2nd.algorithm = ONESITE;
in2nd.restart = true;
conv = false;
// Optimization with sweep algorithm
for(size_t iter = 0; iter < MAX_ITER && !conv; ++iter) {
pout << "\t====================================================================================================" << endl;
pout << "\t\tSWEEP ITERATION [ " << setw(4) << iter << " ] :: ROOT = " << setw(2) << iroot << endl;
pout << "\t====================================================================================================" << endl;
ts.start();
double eswp = make_sweep(esav,in2nd,iroot);
double edif = eswp-esav[iroot];
pout << "\t====================================================================================================" << endl;
pout << "\t\tSWEEP ITERATION [ " << setw(4) << iter << " ] :: ROOT = " << setw(2) << iroot << " FINISHED"
<< " ( " << fixed << setprecision(2) << setw(8) << ts.lap() << " sec. ) " << endl;
pout.precision(16);
pout << "\t\t\tSweep Energy = " << setw(24) << fixed << eswp << " ( delta E = ";
pout.precision(2);
pout << setw(8) << scientific << edif << " ) " << endl;
pout << endl;
if(world.rank() == 0) {
esav[iroot] = eswp;
if(iter > 0 && std::fabs(edif) < in2nd.tolerance) conv = true;
}
#ifndef _SERIAL
boost::mpi::broadcast(world,conv,0);
boost::mpi::broadcast(world,esav,0);
#endif
}
// Stop by no convergence
if(!conv) {
pout << "\t+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-" << endl;
pout << "\t\tNO CONVERGENCE MET FOR ROOT = " << setw(2) << iroot << endl;
pout << "\t\tPROGRAM STOPPED..." << endl;
break;
}
// gaugefix<fermion>(input,iroot);
}
pout << "\t====================================================================================================" << endl;
pout.precision(16);
for(size_t iroot = 0; iroot < K_roots; ++iroot) {
pout << "\t\t\tSweep Energy = " << setw(24) << fixed << esav[iroot] << endl;
}
return esav;
}