source: ZHANGProjects/ICOSIM/CPP/trunk/source/FlukaCollimator.cc @ 2

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <unistd.h>
#include <signal.h>
#include <assert.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cmath>
#include "FlukaCollimator.h"
using namespace std;

FlukaCollimator::FlukaCollimator(const double& ALFX, const double& ALFY, const double& APER_1, const double& APER_2, const double& APER_3, const double& APER_4, const string& APERTYPE, const double& BETX, const double& BETY, const double& DPX, const double& DPY, const double& DX, const double& DY, const string& KEYWORD, const double& L, const double& MUX, const double& MUY, const string& NAME, const double& PTC, const double& PXC, const double& PYC, const double& S, const double& TC, const double& XC, const double& YC, const double& K0L, const double& K0SL, const double& K1L, const double& K1SL, const double& K2L, const double& K2SL, const string& PARENT, const string& meth, const long double& hgap, const long double& hgap2, const double& collang, const long double& pdepth, const long double& pdepth2, const double& tcang, const double& nsig)
    : Collimator(ALFX, ALFY, APER_1, APER_2, APER_3, APER_4, APERTYPE, BETX, BETY, DPX, DPY, DX, DY, KEYWORD, L, MUX, MUY, NAME, PTC, PXC, PYC, S, TC, XC, YC, K0L, K0SL, K1L, K1SL, K2L, K2SL, PARENT, meth, hgap, hgap2, collang, pdepth, pdepth2, tcang, nsig)
{};

FlukaCollimator::FlukaCollimator(Element elt, const double& tcang, const double& nsig, const string& meth)
    : Collimator(elt, tcang, nsig, meth)
{};

FlukaCollimator::FlukaCollimator(const FlukaCollimator& obj)
    : Collimator(obj)
{};

void FlukaCollimator::affiche()
{

    cout << "Fluka collimator: " << endl;

    this->Collimator::affiche();
};

#if defined(FLUKA)
void FlukaCollimator::convertToFluka(const int& turn, particle_info_t& part, const Particle& p1, const double& p0)
{

    double Mion0(0.93827231);//mass of an ion [GeV]

    part.t = p1.coordonnees[0][5];
    part.id = p1.getidentification();
    part.gen = 1;
    part.weight = 1e0;
    part.x = p1.coordonnees[0][0] * 1e2;//change from [m] to [cm]
    part.y = p1.coordonnees[0][2] * 1e2;
    part.z = 0e0;
    part.tz = 1e0 / sqrt(p1.coordonnees[0][1] * p1.coordonnees[0][1] + p1.coordonnees[0][3] * p1.coordonnees[0][3] + 1e0);
    part.tx = p1.coordonnees[0][1] * part.tz;
    part.ty = p1.coordonnees[0][3] * part.tz;
    part.aa = (int)p1.Ap0;
    part.zz = (int)p1.Zp0;
    part.m = Mion0;
    part.pc = p0 * (1e0 + p1.coordonnees[0][4]);//linear momentum

};


void FlukaCollimator::convertFromFluka(Particle& p1, const particle_info_t& particle, double& p0)
{

    p1.setidentification(particle.id - 1);

    cout << "En sortant de Fluka:" <<  p1.getidentification() << endl;

    p1.coordonnees[0][0] = particle.x * 1e-2;//change from [cm] to [m]
    p1.coordonnees[0][2] = particle.y * 1e-2;

    p1.coordonnees[0][1] = particle.tx / particle.tz;
    p1.coordonnees[0][3] = particle.ty / particle.tz;

    p1.Ap0 = particle.aa;
    p1.Zp0 = particle.zz;

    p1.coordonnees[0][4] = (particle.pc - p0) / p0; //(p-p0)/p0
    p1.coordonnees[0][5] = particle.t;

};

void FlukaCollimator::die(char* msg, flukaio_connection_t* conn)
{
    cerr << msg << endl;

    if (conn) {
        flukaio_disconnect(conn);
        conn = NULL;
    }

    exit(1);
}



void FlukaCollimator::collipassfluka(vector <Particle>& bunchstart, vector <Particle>& bunchend, flukaio_connection_t* connection, const int& turn, const double& momentum)
{

    long i;
    int n;
    flukaio_message_t msg;
    particle_info_t part;

    Particle temp;
    double p0;

    p0 = momentum / 1e09;


    for (i = 0; i < bunchstart.size(); ++i) {
        convertToFluka(turn, part, bunchstart[i], p0);
        part.id = (unsigned int)i + 1;
        cout << ">";

        n = flukaio_send_particle(connection, &part);
        if (n < 0) {
            die("Error occurred sending P", connection);
            return;
        }

        // Read incomming messages
        while (flukaio_receive_message(connection, &msg) > 0) {
            if (msg.type == N_PART) {
                convertFromFluka(temp, msg.data.particle, p0);
                bunchend.push_back(temp);
                cout << "<";
            }
        }
    }

    n = flukaio_send_eot(connection, turn + 1);

    if (n < 0) {
        die("Error occurred sending T", connection);
        return;
    }

    // Read incomming messages until end of turn
    do {
        n = flukaio_wait_message(connection, &msg);
        if (n == -1) {
            cout << connection->in_buffer_len << endl;
            cout << connection->out_buffer_len << endl;
            die("Server timeout when waiting end of computation.", connection);
        }
        if (msg.type == N_PART) {
            convertFromFluka(temp, msg.data.particle, p0);
            bunchend.push_back(temp);
            cout << "<";
        }
    } while (msg.type != N_TURN);

    cout << "Turn finished" << endl;

    cout << "Done sending particles" << endl;

};
#endif