void FPairVels::setup()
{
FPairArbitrary::setup();
m_pairFactor.setReturnType(Variant::VECTOR);
m_1stparticleFactor.setReturnType(Variant::VECTOR);
m_2ndparticleFactor.setReturnType(Variant::VECTOR);
// Setting the colours this force works on
size_t col1 = M_MANAGER->getColour(m_species.first);
size_t col2 = M_MANAGER->getColour(m_species.second);
ColourPair *cp = M_MANAGER->cp(col1, col2);
if ((col1 == cp->secondColour()) && (col2 == cp->firstColour())) {
size_t dummy = col1;
col1 = col2;
col2 = dummy;
}
else if ((col1 == cp->firstColour()) && (col2 == cp->secondColour())) {
// MSG_DEBUG("FPairVels::setup", "Force colours same order as ColourPair's colours");
}
else {
throw gError("FPairVels::setup", "No ColourPair for these colours. Contact the programmer.");
}
if(m_cutoff <= 0)
throw gError("FPairVels::setup", "Please define a cutoff >0");
cp->setCutoff(m_cutoff);
}
void FPairArbitrary::setup()
{
FPair::setup();
ColourPair *m_cp = M_MANAGER->cp(M_MANAGER->getColour(m_species.first), M_MANAGER->getColour(m_species.second));
assert(m_cp);
/* if (m_pairFactor.isNull())
throw gError("FPairVector::setup", "Please specify a function for 'pairFactor'.");*/
m_pairFactor.setExpression(m_pairFactorStr);
// m_pairFactor.setReturnType(Variant::VECTOR);
m_pairFactor.setColourPair(m_cp);
m_1stparticleFactor.setExpression(m_1stPExpression);
// m_1stparticleFactor.setReturnType(Variant::VECTOR);
m_1stparticleFactor.setColourPair(m_cp);
m_2ndparticleFactor.setExpression(m_2ndPExpression);
// m_2ndparticleFactor.setReturnType(Variant::VECTOR);
m_2ndparticleFactor.setColourPair(m_cp);
if (m_1stparticleFactor.isNull()) {
throw gError("FPairArbitrary::setup", "For " + m_properties.className() + ": Please specify a function for 'particleFactor'.");
}
if (m_2ndparticleFactor.isNull()) {
throw gError("FPairArbitrary::setup", "For " + m_properties.className() + ": Please specify a function for 'particleFactor'.");
}
if (m_pairFactor.isNull()) {
throw gError("FPairArbitrary::setup", "For " + m_properties.className() + ": Please specify a function for 'pairFactor'.");
}
if(m_symmetry != 1 && m_symmetry != -1)
throw gError("FPairArbitrary::setup", "For " + m_properties.className() + ": m_symmetry = \"" + ObjToString(m_symmetry) +
"\" not allowed. Allowed values are '-1' and '1'.");
}
void FPairTensor::setup()
{
FPairArbitraryWF::setup();
ColourPair *m_cp = M_MANAGER->cp(M_MANAGER->getColour(m_species.first), M_MANAGER->getColour(m_species.second));
m_pairFactor.setReturnType(Variant::TENSOR);
// m_pairFactor.setColourPair(m_cp);
m_1stparticleFactor.setReturnType(Variant::TENSOR);
m_2ndparticleFactor.setReturnType(Variant::TENSOR);
/* if (m_pairFactor.isNull()) {
throw gError("FPairTensor::setup", "Please specify a function for 'pairFactor'.");
}*/
DataFormat::attribute_t firstAttr =
Particle::s_tag_format[m_cp->firstColour()].attrByName(m_tensor_name);
DataFormat::attribute_t secondAttr =
Particle::s_tag_format[m_cp->secondColour()].attrByName(m_tensor_name);
if(firstAttr.datatype != DataFormat::TENSOR)
throw gError("FPairScalar::setup", "the symbol " + m_tensor_name +
" is registerd as a non-tensor for species " +
m_cp->manager()->species(m_cp->firstColour()));
if(secondAttr.datatype != DataFormat::TENSOR)
throw gError("FPairScalar::setup", "the symbol " + m_tensor_name +
" is registerd as a non-tensor for species " +
m_cp->manager()->species(m_cp->secondColour()));
// FIXME: This is general for each FPairArbitrary except for FPairVels. That's why it's still here => refine hierarchy or remove FPairVels
for(size_t i = 0; i < FORCE_HIST_SIZE; ++i)
{
m_force_offset[i].first =
Particle::s_tag_format[m_cp->firstColour()].attrByName(string("force_"
+ m_tensor_name + "_" + ObjToString(i))).offset;
m_force_offset[i].second =
Particle::s_tag_format[m_cp->secondColour()].attrByName(string("force_"
+ m_tensor_name + "_" + ObjToString(i))).offset;
}
// Setting the colours this force works on
size_t col1 = M_MANAGER->getColour(m_species.first);
size_t col2 = M_MANAGER->getColour(m_species.second);
ColourPair *cp = M_MANAGER->cp(col1, col2);
if ((col1 == cp->secondColour()) && (col2 == cp->firstColour())) {
size_t dummy = col1;
col1 = col2;
col2 = dummy;
}
else if ((col1 == cp->firstColour()) && (col2 == cp->secondColour())) {
// MSG_DEBUG("FPairVels::setup", "Force colours same order as ColourPair's colours");
}
else {
throw gError("FPairTensor::setup", "No ColourPair for these colours. Contact the programmer.");
}
}
void ParticleVels::setup()
{
// Peculiarities of this class
if(m_symbolName != "v")
throw gError("ParticleVels::setup", "Attribute 'symbol' has forbidden value " + m_symbolName + ". ParticleVels must have symbol = \"v\"!");
if(!m_overwrite)
throw gError("ParticleVels::setup", "Attribute 'overwrite' has forbidden value \"false\". ParticleVels must have overwrite = \"true\"!");
// All the stuff from the parent can be used if we have done what we
// have done before in ParticleVels::setup()
ParticleCacheArbitrary::setup();
}
// check for consistency of calculator's and triplets' species
void TripletCalculator::checkConsistency() {
tripletList* trl = M_PHASE->returnTripletList(m_listName);
tripletList::iterator firstTr = trl->begin();
if(M_MANAGER->getColour(m_species[0]) != firstTr->a->c)
throw gError("TripletCalculator::findStage", "For module " + name() + ": Inconsistency between the attribute species1=\"" + m_species[0] + "\" of this calculator and the first species in the assigned list '" + m_listName + "'. This is currently not allowed.");
if(M_MANAGER->getColour(m_species[1]) != firstTr->b->c)
throw gError("TripletCalculator::findStage", "For module " + name() + ": Inconsistency between the attribute species2=\"" + m_species[1] + "\" of this calculator and the first species in the assigned list '" + m_listName + "'. This is currently not allowed.");
if(M_MANAGER->getColour(m_species[2]) != firstTr->c->c)
throw gError("TripletCalculator::findStage", "For module " + name() + ": Inconsistency between the attribute species3=\"" + m_species[2] + "\" of this calculator and the first species in the assigned list '" + m_listName + "'. This is currently not allowed.");
}
// Metoda zwraca string dla danego klucza
static string get( const string& key ) {
if (contains(key) ) {
return( property.find( key )->second );
}
else {
gError(key + "-Not found property" );
return( "xxxxxxxxx" );
}
}
// Metoda zwraca double dla danego klucza
static double getSetting( const string& key ) {
if (containsSetings(key) ) {
return( pSettings.find( key )->second );
}
else {
gError(key + "-Not found property" );
return( 0 );
}
}
void OutputPDB::setup()
{
Output::setup();
if(m_posfn == "---")
throw gError("OutputPDB::read: 'positionsfn' not properly defined.");
if (!m_multiple_files) {
m_pos_s.open(m_posfn.c_str());
}
}
/** Metoda zwraca adres powierchni przechowywanej w pamieci. Powierzchnie sa
* wypelnione wczytanymi obrazkami.
* @throw const char* : nazwa metody
*/
SDL_Surface* Resource::getSurf( string Name ){
if( containsSurf(Name) ){
return pSurfaces.find( Name )->second;
}
else{
gError(Name + ":Not found surfaces" );
throw(string("Resource::getSurf"));
}
}
void FPairVels::setForceSlots(Integrator* intr, int thread_no) {
size_t col1 = M_MANAGER->getColour(m_species.first);
size_t col2 = M_MANAGER->getColour(m_species.second);
string dof = "vel_pos";
ColourPair *cp = M_MANAGER->cp(col1, col2);
if (col1 == intr->colour()) {
if (dof == intr->dofIntegr()) {
if (col1 == cp->firstColour()) {
intr->merge() = true;
m_offsetToVec[thread_no].first = intr->offsetToVec()[thread_no];
m_posInVec.first = intr->posInVec();
}
else if (col1 == cp->secondColour()) {
intr->merge() = true;
m_offsetToVec[thread_no].second = intr->offsetToVec()[thread_no];
m_posInVec.second = intr->posInVec();
}
else {
throw gError("FPairVels::setForceSlots", "No match for this Force's colours for the ColourPair. Contact the programmer.");
}
}
}
if (col2 == intr->colour()) {
if (dof == intr->dofIntegr()) {
if (col2 == cp->secondColour()) {
intr->merge() = true;
m_offsetToVec[thread_no].second = intr->offsetToVec()[thread_no];
m_posInVec.second = intr->posInVec();
}
else if (col2 == cp->firstColour()) {
intr->merge() = true;
m_offsetToVec[thread_no].first = intr->offsetToVec()[thread_no];
m_posInVec.first = intr->posInVec();
}
else {
throw gError("FPairVels::setForceSlots", "No match for this Force's colours for the ColourPair. Contact the programmer.");
}
}
}
}
void ParticleCreatorLSE::createParticles() {
//Controller* c = M_CONTROLLER;
MSG_DEBUG(CLASSNAME+("::"+PRETTYFUNC_INFO),"Read matrices");
M_CONTROLLER->registerForSetupAfterParticleCreation(this);
if (m_matfile_A == "")
throw gError("ParticleCreatorLSE::createParticles", "Please define the name of the matrix file A.");
if (m_matfile_B== "")
throw gError("ParticleCreatorLSE::createParticles", "Please define the name of the matrix file B.");
if (m_matfile_C == "")
throw gError("ParticleCreatorLSE::createParticles", "Please define the name of the matrix file C.");
if (m_matfile_E == "")
throw gError("ParticleCreatorLSE::createParticles", "Please define the name of the matrix file E.");
m_matrixA=new MArray2D(m_matfile_A);
m_matrixB=new MArray2D(m_matfile_B);
m_matrixC=new MArray2D(m_matfile_C);
m_matrixE=new MArray2D(m_matfile_E);
*m_matrixA = (m_matrixA)->scalarmult(m_mult_matA);
*m_matrixB = (m_matrixB)->scalarmult(m_mult_matB);
*m_matrixC = (m_matrixC)->scalarmult(m_mult_matC);
*m_matrixE = (m_matrixE)->scalarmult(m_mult_matE);
MSG_DEBUG(CLASSNAME+("::"+PRETTYFUNC_INFO),"Matrix dimensions are: "
"A(" << (m_matrixA->dim1()) << "," << (m_matrixA->dim2()) << "), "<<
"E(" << (m_matrixE->dim1()) << "," << (m_matrixE->dim2()) << "), "<<
"B(" << (m_matrixB->dim1()) << "," << (m_matrixB->dim2()) << "), "<<
"C(" << (m_matrixC->dim1()) << "," << (m_matrixC->dim2()) << ")."
);
MSG_DEBUG(CLASSNAME+("::"+PRETTYFUNC_INFO),"Create superparticle");
Particle p;
p.setColour(m_colour);
size_t offsetA=Particle::s_tag_format[m_colour].attrByName("matrixA").offset;
size_t offsetE=Particle::s_tag_format[m_colour].attrByName("matrixE").offset;
size_t offsetx=Particle::s_tag_format[m_colour].attrByName("stateVector").offset;
size_t offsetv=Particle::s_tag_format[m_colour].attrByName("velocityVector").offset;
p.tag.array2dDoubleByOffset(offsetA).set(m_matrixA);
p.tag.array2dDoubleByOffset(offsetE).set(m_matrixE);
p.tag.array2dDoubleByOffset(offsetx).set(new MArray2D(m_matrixA->dim1(),1,0));
p.tag.array2dDoubleByOffset(offsetv).set(new MArray2D(m_matrixA->dim1(),1,0));
M_PHASE->addParticle(p);
MSG_DEBUG(CLASSNAME+("::"+PRETTYFUNC_INFO),"Done");
}
/** Metoda wyszukuje w tablicy asocjacyjnej fontu o podanej
* nazwie i zwraca wskaznik do niego
*/
TTF_Font* Resource::getFont(string name) {
if (containsFont( name ) ) {
return pFonts.find( name )->second;
}
else
{
gError(name + ":Not found font" );
throw("Resource::getFont");
}
}
void LinearRegression::flush()
{
double sum_x = 0, sum_y = 0, sum_xy = 0, sum_x2 = 0, sum_y2 = 0, sxx, syy, sxy;
double slope, slope_error, intercept;
int n = 0;
/* Initialize our post- and preprocessor functions */
for (int i = 0; i < SPACE_DIMS; i++) {
string s = "box" + string(1, 'X'+i);
m_prefn.constant(s) = m_simulation->phase()->boundary()->boundingBox().size()[i];
m_postfn.constant(s) = m_simulation->phase()->boundary()->boundingBox().size()[i];
}
m_prefn.FromString(m_str_prefn);
m_postfn.FromString(m_str_postfn);
/* Apply m_prefn and do the linear regression */
for (list<data_sp>::iterator i = m_data.begin(); i != m_data.end(); i++) {
double x, y;
x = (*i)->doubleByIndex(m_idx_x);
y = m_prefn.value((*i)->doubleByIndex(m_idx_y));
sum_x += x;
sum_y += y;
sum_xy += x*y;
sum_x2 += x*x;
sum_y2 += y*y;
n++;
}
if(n < 3)
throw gError
("LinearRegression::flush", "I need at least 3 values, but have only "
+ ObjToString(n));
sxy = sum_xy - sum_x*sum_y/n;
sxx = sum_x2 - sum_x*sum_x/n;
syy = sum_y2 - sum_y*sum_y/n;
slope = sxy/sxx;
slope_error = sqrt((syy - (slope*slope*sxx)) / (n - 2));
intercept = sum_y/n - slope*sum_x/n;
data_sp data = m_output.newData();
data->doubleByIndex(IDX_SLOPE) = slope;
// data->doubleByIndex(IDX_SLOPE_ERROR) = slope_error;
data->doubleByIndex(IDX_INTERCEPT) = intercept;
// data->doubleByIndex(IDX_INTERCEPT_ERROR) = 0;
data->doubleByIndex(IDX_VALUE) = m_postfn.value(slope);
distribute(data);
}
void GridMeterScalar::setup()
{
GridMeter::setup();
if (m_colour == ALL_COLOURS)
throw gError("GridMeterScalar::setup", "Please specify a species.");
m_moment_o =
M_GRID_AVERAGER->format().addAttribute
(m_species + STR_DELIMITER + m_scalar_name + "^" + ObjToString(m_moment),
DataFormat::VECTOR_DOUBLE).offset;
m_scalar_o = Particle::s_tag_format[m_colour].attrByName(m_scalar_name).offset;
}
/** Pierwszy poziom obslugi zdarzen. Sprawdzane jest jaki klawisz zostal nacisniety, a
* nastepnie zostaje uruchomiona odpowiednia metoda klasy Game odpowiadajaca za obsluge danego klawisza.
* Jest to filtrowanie zdarzen na rzecz klasy Game.
* @return void
* @param void
*/
void App::processEvent() {
while ( SDL_PollEvent( &pEvent ) )
{
if ( pEvent.type == SDL_QUIT )
{
pIsDone = true;
}
#ifdef DEBUG
/** @TODO Po nacisnieciu F1 wyjscie z aplikacji! */
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_F1 ) {
gError("Pressed F1 key. App is terminated.");
throw("App::processEvent");
}
#endif
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_ESCAPE ) {
gInfo("ESC pressed");
pGame->pressedEsc();
}
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_SPACE ) {
pGame->SpaceDown();
}
else if (pEvent.type == SDL_KEYUP && pEvent.key.keysym.sym == SDLK_SPACE ) {
pGame->SpaceUp();
}
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_RETURN ) {
pGame->pressedReturn();
}
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_LEFT ) {
pGame->pressedLeft();
}
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_RIGHT ) {
pGame->pressedRight();
}
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_UP ) {
pGame->pressedUp();
}
else if (pEvent.type == SDL_KEYDOWN && pEvent.key.keysym.sym == SDLK_DOWN ) {
pGame->pressedDown();
}
else if ( pEvent.type == SDL_KEYDOWN && ( pEvent.key.keysym.sym >= 97 && pEvent.key.keysym.sym >= 122 ) )
{
///@TODO obsluga klawiatury do wpisania highscore
}
///@TODO Reszta zdarzen do dopisania
}
}
void NodeOneChild::read(const xmlNode *xmln)
{
Node::read(xmln);
for (const xmlNode *cur_node = xmln->children; cur_node; cur_node = cur_node->next) {
if (cur_node->type == XML_ELEMENT_NODE) {
if (m_child)
throw gError("NodeOneChild::read", "For " + className() + ": Only one child is allowed for this node.");
m_child = instantiateChild((const char*) cur_node->name);
if (m_child)
m_child->read(cur_node);
}
}
}
_XFX_BEGIN
//
// Resource
//
HRESULT Resource::LoadFile( const String& file )
{
PROFILE( __FUNCTION__, "General" );
mFilename = file;
mPhysicalPath.clear( );
gMess( "Loading %s from file \"%s\"...", mName.c_str( ), file.c_str( ) );
unsigned long filesize;
HRESULT hr;
if( FAILED( hr = FileSystem::Instance( ).FindFile( file, NULL, &mPhysicalPath ) ) ||
FAILED( hr = FileSystem::Instance( ).GetFileSize( file, filesize ) ) )
{
gError( "Can't open file \"%s\"", file.c_str( ) );
return hr;
}
boost::scoped_array< BYTE > pbuf( new BYTE[ filesize ] );
FileSystem::Instance( ).ReadFile( file, pbuf.get( ) );
if( FAILED( hr = LoadMemory( pbuf.get( ), filesize ) ) )
gError( "Loading %s from file \"%s\" failed!", mName.c_str( ), file.c_str( ) );
return hr;
}
void GridMeterVector::setup()
{
GridMeter::setup();
if (m_colour == ALL_COLOURS)
throw gError("GridMeterVector::setup", "Please specify a species.");
m_moment_o =
M_GRID_AVERAGER->format().addAttribute
(m_species + STR_DELIMITER + m_name + "^" + ObjToString(m_moment),
DataFormat::VECTOR_POINT).offset;
m_offset = Particle::s_tag_format[m_colour].attrByName(m_name).offset;
MSG_DEBUG("GridMeterVector::setup", "m_offset = " << m_offset << ", m_name = " << m_name);
}
void BondedPairParticleArbitrary::setup()
{
if(m_expression == "undefined")
throw gError("BondedPairParticleArbitrary::setup", ": Attribute 'expression' has value \"undefined\"");
ColourPair* cp = M_MANAGER->cp(M_MANAGER->getColour(m_species.first), M_MANAGER->getColour(m_species.second));
m_function.setExpression(m_expression);
m_function.setColourPair(cp);
m_1stparticleFactor.setExpression(m_1stPExpression);
m_1stparticleFactor.setColourPair(cp);
m_2ndparticleFactor.setExpression(m_2ndPExpression);
m_2ndparticleFactor.setColourPair(cp);
BondedPairParticleCalc::setup();
}
void GridMeterScalarFourierCos::setup()
{
GridMeterScalar::setup();
// if(m_dir != 0 && m_dir != 1 && m_dir != 2)
// throw gError("GridMeterScalarFourierCos::setup", "Attribute 'direction' has a forbidden value \"" + ObjToString(m_dir) + "\"! It must have value \"0\", \"1\" or \"2\" representing one of the cartesian directions.");
// if(m_lambda == HUGE_VAL)
// throw gError("GridMeterScalarFourierCos::setup","Please define attribute 'waveLength'!");
bool abort = true;
for(size_t i = 0; i < SPACE_DIMS; ++i)
abort = abort && (m_kVec[i] == HUGE_VAL);
if(abort)
throw gError("GridMeterScalarFourierCos::setup","k-vector does not seem to be well defined by attribute 'kVec'.");
// m_k = 2*M_PI/m_lambda;
m_kVec = 2*M_PI*m_kVec;
}
void read_series(istream& df, const string &name)
{
char ch;
vec_convert vc;
series t;
while (df)
{
t.init();
vc.clear();
df >> ws;
if (df.peek() == '*')
{
t.hide = true;
df.ignore();
}
if (hide_series)
t.hide = true;
df >> ws;
ch = get_token(df, t.ID);
if (isspace(ch))
ch = skip_until(df);
if (ch != ',')
continue;
df >> ws;
string str;
ch = get_token(df, str);
try
{
t.f = FindResidual(str);
}
catch (gError)
{
cout << NOEQ << t.ID << " - " << str << " - series ignored" << endl;
while (ch = df.get(), ch != ';' &&
ch != EOF);
continue;
}
parser p(df, name);
SGML el;
if (isspace(ch))
while (df >> ws, ch = df.peek(), ch == '<')
{
p.GetSGML(el);
el.compare("var");
str = el.FindString("name");
if (!str.empty())
{
t.vs.push_back(str);
t.vx.push_back(el.FindDouble("value"));
}
}
if (ch != ',')
ch = skip_until(df);
if (ch == ',')
df.ignore();
else
continue;
while (df >> ws, ch = df.peek(), ch == '<')
{
vc.push_back(convert());
vc.back().read(p.GetSGML(el));
}
if (ch == ',')
df.ignore();
t.read(df, 0, t.f.NameOfX(), t.f.ScaleOfX());
if (!t)
continue;
if (vc.empty())
ser.push_back(t);
else
{
series t1;
t1.hide = t.hide;
t1.ID = t.ID;
t1.f = t.f;
t1.vs = t.vs;
t1.vx = t.vx;
t1.set(t.Ntot(), vc.size());
for (size_t i = 0; i < vc.size(); ++i)
{
if (vc[i].name().empty())
throw gError("read_series: no name while converting");
else
t1.name(i) = vc[i].name();
}
t1.scale() = t.scale();
t1.NOfX() = SearchString(t1.names(), t1.f.NameOfX());
for (size_t i = 0; i < vc.size(); ++i)
vc[i].SetID(t.names());
for (size_t i = 0; i < t.Ntot(); ++i)
{
t1.atr(i) = t.atr(i);
for (size_t j = 0; j < vc.size(); ++j)
t1(i, j) = vc[j](t(i));
}
t1.set_av();
ser.push_back(t1);
}
ser.back().f.SetInput(ser.back().names());
ser.back().f.SetOnceInput(ser.back().vs);
}
}
WeightingFunction::WeightingFunction()
{
throw gError("WeightingFunction::WeightingFunction(default)", "Should not be called. Contact the programmer.");
}
void BondedPairParticleCalc::setup()
{
if(m_symmetry != -1 && m_symmetry != 1)
throw gError("BondedPairParticleCalc::setup", "For module " + name() + ": Define attribute 'symmetry'! It may only be \"-1\" (antisymmetry) or \"1\" (symmetry). Currently it is " + ObjToString(m_symmetry) + "!");
if(m_listName == "undefined")
throw gError("BondedPairParticleCalc::setup", "Attribute 'listName' is undefined!");
if(m_phaseUser != 0 && m_phaseUser != 1 && m_phaseUser != 2)
throw gError("BondedPairParticleCalc::setup", ": Attribute 'stage' is " + ObjToString(m_phaseUser) + ", which is none of the allowed values \"0\", \"1\", \"2\".");
if(m_species.first == "undefined")
throw gError("BondedPairParticleCalc::setup", "For module " + name() + ": Attribute 'species1' has value \"undefined\".");
if(m_species.second == "undefined")
throw gError("BondedPairParticleCalc::setup", "For module " + name() + ": Attribute 'species2' has value \"undefined\".");
ColourPair* cp = M_MANAGER->cp(M_MANAGER->getColour(m_species.first), M_MANAGER->getColour(m_species.second)/*m_species*/);
// next lines are just necessary for non-bonded pairs, so not here!
// cp->setNeedPairs(true);
// cp->setCutoff(m_cutoff);
if(m_overwrite)
{
try
{
m_slots.first = Particle::s_tag_format[cp->firstColour()].indexOf(m_symbolName, m_datatype);
m_slots.first = Particle::s_tag_format[cp->firstColour()].offsetByIndex(m_slots.first);
}
catch(gError& err)
{
throw gError("BondedPairParticleCalc::setup", ": search for symbol for species '" + M_MANAGER->species(cp->firstColour()) + " failed, but need one because 'overwrite = \"yes\"'. The message was " + err.message());
}
try
{
m_slots.second = Particle::s_tag_format[cp->secondColour()].indexOf(m_symbolName, m_datatype);
m_slots.second = Particle::s_tag_format[cp->secondColour()].offsetByIndex(m_slots.second);
}
catch(gError& err)
{
throw gError("BondedPairParticleCalc::setup", ": search for symbol for species '" + M_MANAGER->species(cp->secondColour()) + " failed, but need one because 'overwrite = \"yes\"'. The message was " + err.message());
}
}
else // m_overwrite = false
{
if(Particle::s_tag_format[cp->firstColour()].attrExists(m_symbolName))
throw gError("BondedPairParticleCalc::setup", ": Symbol " + m_symbolName + " is already existing for species '" + M_MANAGER->species(cp->firstColour()) + "'. Second definition is not allowed for overwrite = \"no\"");
if(Particle::s_tag_format[cp->secondColour()].attrExists(m_symbolName))
throw gError("BondedPairParticleCalc::setup", ": Symbol " + m_symbolName + " is already existing for species '" + M_MANAGER->species(cp->secondColour()) + "'. Second definition is not allowed for overwrite = \"no\"");
// see CONVENTION5 for rule about persistencies
m_slots.first = Particle::s_tag_format[cp->firstColour()].addAttribute(m_symbolName, m_datatype, /*persist.first*/false, m_symbolName).offset;
if(cp->firstColour() != cp->secondColour())
{
// see CONVENTION5 for rule about persistencies
m_slots.second = Particle::s_tag_format[cp->secondColour()].addAttribute(m_symbolName, m_datatype, /*persist.second*/false, m_symbolName).offset;
}
else m_slots.second = m_slots.first;
} // end of else-case where m_overwrite = false
MSG_DEBUG("BondedPairParticleCalc::setup", ": registering " << this->name() << ".");
if(m_phaseUser == 0)
cp->registerBondedCalc_0(this);
else if(m_phaseUser == 1)
cp->registerBondedCalc(this);
else // so it is 2
{
ValCalculator* vc = copyMySelf() /*new BondedPairParticleCalc(*this)*/;
copyMembersTo(vc);
MSG_DEBUG("BondedPairParticleCalc::setup", ": registering copy of " << this->name() << ", CP = (" << cp->firstColour() << ", " << cp->secondColour() << ")");
cp->registerBondedCalc(vc);
cp->registerBondedCalc_0(this);
}
}
void GenFSolo::computeForces(int force_index)
{
throw gError("GenFSolo::computeForces", "Fatal error: do not call GenFSolo::computeForces(int force_index)!!! Needs a Pairdist argument. Please contact the programmer!");
}
void BoundaryCouette::setup()
{
bool_point_t periodic;
Reflector *inner_refl, *outer_refl;
MSG_DEBUG("BoundaryCouette::setup", "Creating geometry for rotational Couette flow.");
BoundaryArbitrary::setup();
if (!m_periodic)
throw gError("BoundaryCouette::setup", "Non-periodic Couette flow is not yet supported.");
periodic.x = periodic.y = false;
periodic.z = m_periodic;
/* Create a new container and tell it in which direction
the boundary is periodic.
*/
m_container = new WallContainer(m_reflectors[0]);
m_container->setPeriodicityFront(periodic);
m_container->setPeriodicityBack(periodic);
inner_refl = findReflector(m_inner_reflector);
outer_refl = findReflector(m_outer_reflector);
/* Create the geometry. Loop over elements of the drums edges.
In the first loop, the vertices are being created and in the
second loop the vertices are connected by walls.
*/
/* Create vertices. Note: The vertices are numbered in the order
of their creation.
*/
for (int i = 0; i < m_n_edge_elements; ++i) {
point_t inner_pos, outer_pos;
inner_pos.z = outer_pos.z = 0;
inner_pos.x = m_inner_radius * cos(i*2*M_PI/m_n_edge_elements);
inner_pos.y = m_inner_radius * sin(i*2*M_PI/m_n_edge_elements);
outer_pos.x = m_outer_radius * cos(i*2*M_PI/m_n_edge_elements);
outer_pos.y = m_outer_radius * sin(i*2*M_PI/m_n_edge_elements);
m_container->addVertex(inner_pos);
m_container->addVertex(outer_pos);
inner_pos.z += m_height;
outer_pos.z += m_height;
m_container->addVertex(inner_pos);
m_container->addVertex(outer_pos);
}
/* Create walls */
for (int i = 0; i < m_n_edge_elements; ++i) {
/* vib = Vertex Inner Bottom */
int next_i, vib1, vob1, vit1, vot1, vib2, vob2, vit2, vot2;
next_i = (i+1)%m_n_edge_elements;
vib1 = i*4;
vob1 = i*4+1;
vit1 = i*4+2;
vot1 = i*4+3;
vib2 = next_i*4;
vob2 = next_i*4+1;
vit2 = next_i*4+2;
vot2 = next_i*4+3;
ADDRECT(vib1, vib2, vit2, vit1, inner_refl);
ADDRECT(vot1, vot2, vob2, vob1, outer_refl);
}
m_container->updateBoundingBox();
}
void BoundarySTL::setup(Simulation* sim, ManagerCell *mgr)
{
// BoundaryWithInlet::setup(sim, mgr);
/* Cell subdivision */
region_t *inlet, *r;
bool_point_t periodic = { { { false, false, false } } };
/* Do we have to construct an inlet??? */
if (m_inlet_str != "none") {
int dir;
double coord;
ParticleCreatorInlet *pc = NULL;
MSG_DEBUG("BoundarySTL::setup", "Adding inlet.");
for(vector<ParticleCreator*>::iterator pcIter = m_pcList.begin();
pcIter != m_pcList.end(); ++pcIter)
{
if(typeid(**pcIter) == typeid(ParticleCreatorInlet))
{
if(pc)
throw gError("BoundarySTL::setup", "Please define only one ParticleCreatorInlet");
pc = (ParticleCreatorInlet*) (*pcIter);
}
}
if(!pc)
throw gError("BoundarySTL::setup", "Since 'inlet' is not \"none\", you must define a ParticleCreatorInlet.");
// if (typeid(*pcList[0]) != typeid(ParticleCreatorInlet))
// throw gError
// ("BoundarySTL::setup"
// "Please do only use ParticleCreatorInlet with BoundarySTL if you wish to specify an inlet.");
//
// pc = (ParticleCreatorInlet*) pcList[0];
//
//
// MSG_DEBUG("BoundarySTL::setup", "Using particle creator: " << pc->className());
dir = m_inlet_str[0] - 'x';
m_inlet_normal.assign(0);
if (m_inlet_pos_str == "bottom") {
m_inlet_normal[dir] = 1;
coord = m_container->boundingBox().corner1[dir];
} else {
m_inlet_normal[dir] = -1;
coord = m_container->boundingBox().corner2[dir];
}
// MSG_DEBUG("BoundartSTL::setup", "m_inlet_normal = " << m_inlet_normal);
/* First, delete all walls that might hinder flow through the inlet. */
list<Wall*> &walls = m_container->walls();
for (list<Wall*>::iterator i = walls.begin(); i != walls.end(); ) {
if (((*i)->normal() - m_inlet_normal).abs() < g_geom_eps) {
/* Fixme!!! Does only work right now. */
WallTriangle *wt = (WallTriangle*) (*i);
bool del = true;
for (int j = 0; j < 3; j++) {
// MSG_DEBUG("BoundarySTL::setup", "... = " << wt->corner(j)[dir] - coord);
if (abs(wt->corner(j)[dir] - coord) >= g_geom_eps)
del = false;
}
if (del) {
list<Wall*>::iterator d = i;
int vs[3];
i++;
// MSG_DEBUG("BoundarySTL::setup", "Deleting wall.");
for (int j = 0; j < 3; j++) {
vs[j] = m_inlet_base_surface.needVertex(wt->corner(j));
}
m_container->deleteWall(d);
m_inlet_base_surface.addWall
(new WallTriangle(&m_inlet_base_surface, NULL, vs[0], vs[1], vs[2]));
} else
i++;
} else
i++;
}
/* Complicated version, add surfaces */
MSG_DEBUG("BoundarySTL::setup", "Finding pairs.");
vector< pair<int, int> > pairs;
point_t middle_point = { { { 0, 0, 0 } } };
size_t n_points = 0;
for (list<Wall*>::iterator i = walls.begin(); i != walls.end(); i++) {
WallTriangle *w = ((WallTriangle*) (*i));
vector<int> corners;
for (int j = 0; j < 3; j++) {
if (abs(w->corner(j)[dir] - coord) < g_geom_eps)
corners.push_back(w->cornerVertex(j));
}
// MSG_DEBUG("BoundarySTL::setup", "corners.size() = " << corners.size());
if (corners.size() == 2) {
pair<int, int> p;
p.first = corners[0];
p.second = corners[1];
middle_point += m_container->vertex(p.first);
middle_point += m_container->vertex(p.second);
n_points += 2;
pairs.push_back(p);
} else if (corners.size() == 3)
throw gError("BoundarySTL::setup", "FATAL: corners.size() = 3 -> should not happpen.");
}
middle_point /= n_points;
MSG_DEBUG("BoundarySTL::setup", "pairs.size() = " << pairs.size());
MSG_DEBUG("BoundarySTL::setup", "Creating walls.");
vector<int> partners;
partners.resize(m_container->vertices().size()+pairs.size(), -1);
for (vector< pair<int, int> >::iterator i = pairs.begin(); i != pairs.end(); i++) {
int a, b;
point_t n1, n2, mv;
a = i->first;
b = i->second;
if (partners[a] == -1) {
point_t p = m_container->vertex(a);
p += -m_inlet_length*m_inlet_normal;
partners[a] = m_container->addVertex(p);
}
if (partners[b] == -1) {
point_t p = m_container->vertex(b);
p += -m_inlet_length*m_inlet_normal;
partners[b] = m_container->addVertex(p);
}
n1 = (m_container->vertex(b)-m_container->vertex(a)).cross
(m_container->vertex(partners[a])-m_container->vertex(b));
n2 = (m_container->vertex(partners[a])-m_container->vertex(b)).cross
(m_container->vertex(partners[b])-m_container->vertex(partners[a]));
mv = middle_point-m_container->vertex(b);
/* Does the vector n1 point towards the middle? */
if (n1 * mv > 0) {
m_container->addWall
(new WallTriangle(m_container, m_container->reflector(),
a, b, partners[a]));
} else {
m_container->addWall
(new WallTriangle(m_container, m_container->reflector(),
b, a, partners[a]));
}
/* Does the vector n2 point towards the middle? */
if (n2 * mv > 0) {
m_container->addWall
(new WallTriangle(m_container, m_container->reflector(),
b, partners[a], partners[b]));
} else {
m_container->addWall
(new WallTriangle(m_container, m_container->reflector(),
b, partners[b], partners[a]));
}
}
/* Now, readd the closing surface */
MSG_DEBUG("BoundarySTL::setup", "Readding closing surface.");
for (list<Wall*>::iterator i = m_inlet_base_surface.walls().begin(); i != m_inlet_base_surface.walls().end(); ++i) {
WallTriangle *wall = (WallTriangle*) *i;
int v1, v2, v3;
v1 = m_container->findVertex(wall->corner(0) - m_inlet_length * m_inlet_normal, g_geom_eps);
v2 = m_container->findVertex(wall->corner(1) - m_inlet_length * m_inlet_normal, g_geom_eps);
v3 = m_container->findVertex(wall->corner(2) - m_inlet_length * m_inlet_normal, g_geom_eps);
m_container->addWall
(new WallTriangle(m_container, m_container->reflector(),
v1, v2, v3));
}
/* Easy version */
/* vector<point_t> &vertices = m_container->vertices();
for (vector<point_t>::iterator i = vertices.begin(); i != vertices.end(); i++) {
if (abs((*i)[dir] - coord) < g_geom_eps) {
(*i)[dir] -= m_inlet_normal[dir]*m_inlet_length;
}
}*/
m_container->vertexChanged();
m_container->updateBoundingBox();
m_proposedSize = m_container->boundingBox().corner2;
// next will also call Boundary::setup => this may lead to addition of a frame
BoundaryWithInlet::setup(sim, mgr);
point_t inlet_c1, inlet_c2, r_c1, r_c2;
Phase* phase = (Phase*) m_parent;
if (m_inlet_pos_str == "bottom") {
inlet_c1 = m_container->boundingBox().corner1;
inlet_c2 = m_container->boundingBox().corner2;
inlet_c2[dir] = inlet_c1[dir] + m_inlet_length;
r_c1 = m_container->boundingBox().corner1;
// r_c1[dir] += m_inlet_length;
r_c2 = m_container->boundingBox().corner2;
// take the frame into account if existent
if(m_frontFrame[dir]) inlet_c2[dir] += phase->pairCreator()->interactionCutoff();
// if(m_frontFrame[dir]) inlet_c2[dir] += sim->maxCutoff;
r_c1[dir] = inlet_c2[dir];
} else {
inlet_c1 = m_container->boundingBox().corner1;
inlet_c2 = m_container->boundingBox().corner2;
inlet_c1[dir] = inlet_c2[dir] - m_inlet_length;
r_c1 = m_container->boundingBox().corner1;
r_c2 = m_container->boundingBox().corner2;
// r_c2[dir] -= m_inlet_length;
// take the frame into account if existent
if(m_endFrame[dir]) inlet_c1[dir] -= phase->pairCreator()->interactionCutoff();
// if(m_endFrame[dir]) inlet_c1[dir] -= sim->maxCutoff;
r_c2[dir] = inlet_c1[dir];
}
/* *New style* inlets with constant density */
// periodic[dir] = true;
periodic[dir] = false;
inlet = mgr->cellSubdivide(sim->maxCutoff, inlet_c1, inlet_c2, periodic, 1, pc,
dir, (int) m_inlet_normal[dir], P_CREATE);
pc->setRegion(inlet);
// mgr->setPeriodicity(periodic);
periodic[dir] = false;
r = mgr->cellSubdivide(sim->maxCutoff, r_c1, r_c2, periodic, 0, pc, dir,
(int) -m_inlet_normal[dir], P_DELETE);
MSG_DEBUG("BoundarySTL::setup", "r->n_cells = " << r->n_cells <<
", inlet->n_cells = " << inlet->n_cells);
// ManagerCell::connect
// ((int) m_inlet_normal[dir]*dir-(m_inlet_normal[dir] < 0 ? 1 : 0), inlet, r, periodic, OUTLET);
ManagerCell::connect
((int) m_inlet_normal[dir]*dir-(m_inlet_normal[dir] < 0 ? 1 : 0), inlet, r, periodic, NEIGHBOR);
} else {
m_proposedSize = m_container->boundingBox().corner2;
// next could add a frame
BoundaryWithInlet::setup(sim, mgr);
r = mgr->cellSubdivide
(sim->maxCutoff, m_container->boundingBox().corner1, m_container->boundingBox().corner2, periodic, 0);
}
mgr->cellSubdivisionFinished();
mgr->assignContainer(m_container);
int counter = 0;
MSG_DEBUG("BoundarySTL::setup", "Writing geometry information to '" << m_geometry_filename << "'.");
m_container->toVTK(m_geometry_filename);
}
void FPairVels::computeForces(Particle* part, int force_index)
{
throw gError("FPairVels::computeForces", "Fatal error: do not call FPairVels::computeForces(Particle* part, int force_index)!!! Needs a Pairdist argument. Please contact the programmer!");
}
void FirstHarmonic::push(data_sp data)
{
if(!negativeFound)
{
data_sp new_data = m_output.newData();
double /*left, right,*/ len, step, pos, mul;
double value = 0;
vector<point_t> *vp;
vector<point_t> *cp;
new_data->doubleByIndex(IDX_TIME) = data->doubleByIndex(m_idx_time);
cp = data->vectorPointByIndex(m_idx_x).value();
vp = data->vectorPointByIndex(m_idx_y).value();
int grid_size = (*cp).size();
// left = data->doubleByIndex(m_idx_left);
// right = data->doubleByIndex(m_idx_right);
// grid_size = data->intByIndex(m_idx_grid_size);
assert(grid_size > 1);
step = (*cp)[1].x - (*cp)[0].x;
// are the cells aligned in x-direction?
if(step > g_geom_eps)
{
// make sure there is not more than one cell in y-direction
if ((*cp)[1].y - (*cp)[0].y > g_geom_eps)
throw gError("FirstHarmonic::push", "multiple cells in more than one direction"
" found. This is not allowed with FirstHarmonic");
len = (*cp)[grid_size - 1].x - (*cp)[0].x + step;
pos = (*cp)[0].x - step/2;
mul = 2*M_PI/len;
}
else // so it's the y-direction
{
step = (*cp)[1].y - (*cp)[0].y;
assert(step > g_geom_eps);
len = (*cp)[grid_size - 1].y - (*cp)[0].y + step;
pos = (*cp)[0].y - step/2;
mul = 2*M_PI/len;
}
for (int i = 0; i < grid_size; i++) {
/* Currently, we integrate approximating the profile by step functions.
The profile should be interpolated linearly, quadratically? */
value += 0.5*(sin((pos + step/2) * mul) /*+ sin(pos * mul)*/) * (*vp)[i].z;
MSG_DEBUG("FirstHarmonic::push", "pos=" << pos << "\nstep=" << step << "\nmul=" << mul << "\nsin((pos+step)*mul) = sin((" << pos << "+" << step << ")*" << mul << ")=" << sin((pos+step)*mul) << "\nsin(pos*mul)=" << sin(pos*mul) << "\nvalue = " << value << "\nfac=" << 0.5*(sin((pos + step) * mul) + sin(pos * mul)) << "\nvel=" << (*vp)[i].z);
pos += step;
}
// first check is for abort if noise to large
// second check avoids logarithms of negative numbers
if(value < oldValue && value > 0)
{
new_data->doubleByIndex(IDX_INTENSITY) = value;
distribute(new_data);
oldValue = value;
}
else negativeFound = true;
}
}
void TripletCalculator::setup()
{
M_SIMULATION->controller()->registerForSetupAfterParticleCreation(this);
if(m_symbolName == "undefined")
throw gError("TripletCalculator::setup", "Attribute 'symbol' undefined!");
if(m_listName == "undefined")
throw gError("TripletCalculator::setup", "Attribute 'listName' undefined!");
// add attributes
if(m_species[0] == "undefined")
throw gError("TripletCalculator::setup", ": Attribute 'species1' has value \"undefined\"!");
if(m_species[1] == "undefined")
throw gError("TripletCalculator::setup", ": Attribute 'species2' has value \"undefined\"!");
if(m_species[2] == "undefined")
throw gError("TripletCalculator::setup", ": Attribute 'species3' has value \"undefined\"!");
m_firstColour = M_MANAGER->getColour(m_species[0]);
m_secondColour = M_MANAGER->getColour(m_species[1]);
m_thirdColour = M_MANAGER->getColour(m_species[2]);
if(m_overwrite)
{
for(size_t p = 0; p < 3; ++p) {
try
{
m_slots[p] = Particle::s_tag_format[M_MANAGER->getColour(m_species[p])].indexOf(m_symbolName, m_datatype);
m_slots[p] = Particle::s_tag_format[M_MANAGER->getColour(m_species[p])].offsetByIndex(m_slots[p]);
}
catch(gError& err)
{
throw gError("TripletCalculator::setup", ": search for symbol for species '" + m_species[p] + " failed. The message was " + err.message());
}
} // end for(size_t p = 0
}
else // m_overwrite = false
{
if(Particle::s_tag_format[M_MANAGER->getColour(m_species[0])].attrExists(m_symbolName))
throw gError("TripletCalculator::setup", ": Symbol " + m_symbolName + " is already existing for species '" + m_species[0] + "'. Second definition is not allowed for overwrite = \"no\"");
if(Particle::s_tag_format[M_MANAGER->getColour(m_species[1])].attrExists(m_symbolName))
throw gError("TripletCalculator::setup", ": Symbol " + m_symbolName + " is already existing for species '" + m_species[1] + "'. Second definition is not allowed for overwrite = \"no\"");
if(Particle::s_tag_format[M_MANAGER->getColour(m_species[2])].attrExists(m_symbolName))
throw gError("TripletCalculator::setup", ": Symbol " + m_symbolName + " is already existing for species '" + m_species[2] + "'. Second definition is not allowed for overwrite = \"no\"");
MSG_DEBUG("TripletCalculator::setup", "adding symbol with name " << m_symbolName);
// see CONVENTION5 for rule about persistencies
m_slots[0] = Particle::s_tag_format[M_MANAGER->getColour(m_species[0])].addAttribute(m_symbolName, m_datatype, /*persist.first*/false, m_symbolName).offset;
if(m_species[0] != m_species[1])
{
// see CONVENTION5 for rule about persistencies
m_slots[1] = Particle::s_tag_format[M_MANAGER->getColour(m_species[1])].addAttribute(m_symbolName, m_datatype, /*persist.first*/false, m_symbolName).offset;
}
else m_slots[1] = m_slots[0];
if(m_species[2] == m_species[0])
m_slots[2] = m_slots[0];
else if(m_species[2] == m_species[1])
m_slots[2] = m_slots[1];
else
// see CONVENTION5 for rule about persistencies
m_slots[2] = Particle::s_tag_format[M_MANAGER->getColour(m_species[2])].addAttribute(m_symbolName, m_datatype, /*persist.first*/false, m_symbolName).offset;
} // end of else of if(m_overwrite == false)
if(m_phaseUser == 0)
M_PHASE->registerBondedCalc_0(this);
else if(m_phaseUser == 1)
M_PHASE->registerBondedCalc(this);
else // so it is 2
{
TripletCalculator* vc = copyMySelf();
assert(((TripletCalculator*) vc)->m_symbolName == m_symbolName);
assert(vc->stage() == m_stage);
assert(((TripletCalculator*) vc)->m_slots[0] == m_slots[0]);
assert(((TripletCalculator*) vc)->m_slots[1] == m_slots[1]);
assert(((TripletCalculator*) vc)->m_slots[2] == m_slots[2]);
assert(((TripletCalculator*) vc)->m_parent == m_parent);
assert(((TripletCalculator*) vc)->m_overwrite == m_overwrite);
assert(((TripletCalculator*) vc)->m_species[0] == m_species[0]);
assert(((TripletCalculator*) vc)->m_species[1] == m_species[1]);
assert(((TripletCalculator*) vc)->m_species[2] == m_species[2]);
MSG_DEBUG("TripletCalculator::setup", ": registering copy.");
M_PHASE->registerBondedCalc(vc);
M_PHASE->registerBondedCalc_0(this);
}
}
void BoundaryObstacle::setup()
{
int v0, v1, v2, v3, v4, v5, v6, v7;
BoundaryCuboid::setup();
// consistency check
double upperObstcl, lowerObstcl;
for(size_t i = 0; i < SPACE_DIMS; ++i)
{
upperObstcl = m_obstacle_center[i] + m_obstacle_size[i]/2;
lowerObstcl = m_obstacle_center[i] - m_obstacle_size[i]/2;
/* MSG_DEBUG("BoundaryObstacle::setup", "upperObstcl=" << upperObstcl << ", lowerObstcl=" << lowerObstcl << ", m_box_size[i]=" << m_box_size[i]);*/
if(upperObstcl > m_box_size[i] || lowerObstcl < 0)
throw gError("BoundaryObstacle::setup", "Obstacle exceeds the box in "
+ string(1, 'x'+1) + "-direction");
}
ADDVERTEX(v0,
m_obstacle_center.x - m_obstacle_size.x/2,
m_obstacle_center.y - m_obstacle_size.y/2,
m_obstacle_center.z - m_obstacle_size.z/2);
ADDVERTEX(v1,
m_obstacle_center.x + m_obstacle_size.x/2,
m_obstacle_center.y - m_obstacle_size.y/2,
m_obstacle_center.z - m_obstacle_size.z/2);
ADDVERTEX(v2,
m_obstacle_center.x + m_obstacle_size.x/2,
m_obstacle_center.y + m_obstacle_size.y/2,
m_obstacle_center.z - m_obstacle_size.z/2);
ADDVERTEX(v3,
m_obstacle_center.x - m_obstacle_size.x/2,
m_obstacle_center.y + m_obstacle_size.y/2,
m_obstacle_center.z - m_obstacle_size.z/2);
ADDVERTEX(v4,
m_obstacle_center.x - m_obstacle_size.x/2,
m_obstacle_center.y - m_obstacle_size.y/2,
m_obstacle_center.z + m_obstacle_size.z/2);
ADDVERTEX(v5,
m_obstacle_center.x + m_obstacle_size.x/2,
m_obstacle_center.y - m_obstacle_size.y/2,
m_obstacle_center.z + m_obstacle_size.z/2);
ADDVERTEX(v6,
m_obstacle_center.x + m_obstacle_size.x/2,
m_obstacle_center.y + m_obstacle_size.y/2,
m_obstacle_center.z + m_obstacle_size.z/2);
ADDVERTEX(v7,
m_obstacle_center.x - m_obstacle_size.x/2,
m_obstacle_center.y + m_obstacle_size.y/2,
m_obstacle_center.z + m_obstacle_size.z/2);
ADDRECT(v2, v6, v5, v1, m_reflector_str[0]);
ADDRECT(v4, v7, v3, v0, m_reflector_str[0]);
ADDRECT(v1, v5, v4, v0, m_reflector_str[1]);
ADDRECT(v7, v6, v2, v3, m_reflector_str[1]);
ADDRECT(v3, v2, v1, v0, m_reflector_str[2]);
ADDRECT(v5, v6, v7, v4, m_reflector_str[2]);
m_container->updateBoundingBox();
MSG_DEBUG("BoundaryObstacle::read", "box: " << m_container->boundingBox().corner1 << " - " << m_container->boundingBox().corner2);
}
