Beispiel #1
0
EGS_AffineTransform* EGS_AffineTransform::getTransformation(EGS_Input *i) {
    if( !i ) return 0;
    EGS_Input *input; bool delete_it = false;
    if( i->isA("transformation") ) input = i;
    else {
        input = i->takeInputItem("transformation");
        if( !input ) return 0;
        delete_it = true;
    }
    EGS_Vector t; vector<EGS_Float> tmp;
    int err = input->getInput("translation",tmp);
    if( !err && tmp.size() == 3 ) t = EGS_Vector(tmp[0],tmp[1],tmp[2]);
    EGS_AffineTransform *result;
    err = input->getInput("rotation vector",tmp);
    if( !err && tmp.size() == 3 )
        result = new EGS_AffineTransform(
           EGS_RotationMatrix(EGS_Vector(tmp[0],tmp[1],tmp[2])),t);
    else {
        err = input->getInput("rotation",tmp);
        if( !err ) {
            if( tmp.size() == 2 ) result = new EGS_AffineTransform(
                    EGS_RotationMatrix(tmp[0],tmp[1]),t);
            else if( tmp.size() == 3 ) result = new EGS_AffineTransform(
                    EGS_RotationMatrix(tmp[0],tmp[1],tmp[2]),t);
            else if( tmp.size() == 4 ) {
                EGS_Vector tmp1(tmp[0],tmp[1],tmp[2]);
                EGS_RotationMatrix R1(tmp1);
                EGS_RotationMatrix R2(EGS_RotationMatrix::rotZ(tmp[3]));
                EGS_RotationMatrix Rtot = R1.inverse()*R2*R1;
                result = new EGS_AffineTransform(Rtot,t);
            }
            else if( tmp.size() == 9 ) {
                EGS_RotationMatrix R(tmp[0],tmp[1],tmp[2],
                                     tmp[3],tmp[4],tmp[5],
                                     tmp[6],tmp[7],tmp[8]);
                if( !R.isRotation() )
                    egsWarning("getTransformation: the rotation specified by\n"
                       "   %g %g %g\n   %g %g %g\n   %g %g %g\n"
                       " is not a rotation\n",tmp[0],tmp[1],tmp[2],
                       tmp[3],tmp[4],tmp[5],tmp[6],tmp[7],tmp[8]);
                result = new EGS_AffineTransform(R,t);
            }
            else result = new EGS_AffineTransform(EGS_RotationMatrix(),t);
        }
        else result = new EGS_AffineTransform(EGS_RotationMatrix(),t);
    }
    if( delete_it ) delete input;
    return result;
}
Beispiel #2
0
EGS_Object *EGS_ObjectFactory::createObjects(EGS_Input *i,
        const string &section_delimeter, const string &object_delimeter,
        const string &select_key, const char *funcname, bool unique) {
    if (!i) {
        egsWarning("EGS_ObjectFactory::createObjects(): null input?\n");
        return 0;
    }
    EGS_Input *input = i;
    if (!i->isA(section_delimeter)) {
        input = i->takeInputItem(section_delimeter);
        if (!input) {
            egsWarning("EGS_ObjectFactory::createObjects(): the input is"
                       " not of type %s and also does not have items of this type\n",
                       section_delimeter.c_str());
            return 0;
        }
    }
    EGS_Input *ij;
    int errors = 0;
    while ((ij = input->takeInputItem(object_delimeter)) != 0) {
        EGS_Object *o = createSingleObject(ij,funcname,unique);
        if (!o) {
            errors++;
        }
        delete ij;
    }
    if (errors) egsWarning("EGS_ObjectFactory::createObjects(): %d errors"
                               " occured while creating objects\n",errors);
    string sought_object;
    EGS_Object *o = 0;
    if (objects.size() > 0) {
        o = objects[objects.size()-1];
    }
    int err = input->getInput(select_key,sought_object);
    if (!err) {
        o = getObject(sought_object);
        if (!o) egsWarning("EGS_ObjectFactory::createObjects(): an object "
                               "with the name %s does not exist\n",sought_object.c_str());
    }
    return o;
}
EGS_ENVELOPEG_EXPORT EGS_BaseGeometry* createGeometry(EGS_Input *input) {
    if( !input ) {
        egsWarning(eeg_message1,eeg_message2);
        return 0;
    }
    //
    // *** new indexing style
    //
    int indexing = 0;
    input->getInput("new indexing style",indexing);
    //
    // *** Base geometry
    //
    EGS_Input *i = input->takeInputItem(eeg_keyword1);
    if( !i ) {
        egsWarning(eeg_message1,eeg_message3); return 0;
    }
    EGS_Input *ig = i->takeInputItem(eeg_keyword2);
    EGS_BaseGeometry *g;
    if( ig ) { // defined inline
        g = EGS_BaseGeometry::createSingleGeometry(ig);
        delete ig;
        if( !g ) {
            egsWarning(eeg_message1,eeg_message4);
            delete i; return 0;
        }
    }
    else {  // defined via a name of a previously defined geometry
        string bgname;
        int err = i->getInput(eeg_keyword1,bgname);
        delete i;
        if( err ) {
            egsWarning(eeg_message1,eeg_message5); return 0;
        }
        g = EGS_BaseGeometry::getGeometry(bgname);
        if( !g ) {
            egsWarning(eeg_message6,bgname.c_str()); return 0;
        }
    }
    vector<EnvelopeAux *> fgeoms;
    EGS_Input *ix;
    while( (ix = input->takeInputItem("inscribe in regions")) != 0 ) {
        vector<string> values;
        ix->getInput("inscribe in regions",values);
        if( values.size() < 2 ) egsWarning("createGeometry(envelope geometry):"
              " %d inputs for 'inscribe in regions'? 2 or more are needed\n",values.size());
        else {
            EGS_BaseGeometry *gj = EGS_BaseGeometry::getGeometry(values[0]);
            if( !gj ) egsWarning(eeg_message6,values[0].c_str());
            else {
                EnvelopeAux *aux = new EnvelopeAux;
                aux->g = gj;
                aux->nreg = values.size()-1;
                aux->regs = new int [aux->nreg];
                for(int j=0; j<aux->nreg; j++)
                    aux->regs[j] = atoi(values[j+1].c_str());
                fgeoms.push_back(aux);
            }
        }
        delete ix;
    }
    if( fgeoms.size() > 0 ) {
        EGS_BaseGeometry *result = new EGS_FastEnvelope(g,fgeoms,"",indexing);
        result->setName(input);
        for(int j=0; j<fgeoms.size(); j++) delete fgeoms[j];
        return result;
    }

    //
    // *** Inscribed geometries
    //
    i = input->takeInputItem(eeg_keyword3);
    vector<EGS_BaseGeometry *> geoms;
    if( !i ) {
        if( fgeoms.size() ) egsWarning(eeg_message1,eeg_message7);
    }
    else {
        // first try for inscribed geometries defined inline
        while( (ig = i->takeInputItem(eeg_keyword2)) != 0 ) {
            EGS_BaseGeometry *gj = EGS_BaseGeometry::createSingleGeometry(ig);
            delete ig;
            if( !gj ) egsWarning(eeg_message1,eeg_message8);
            else geoms.push_back(gj);
        }
        // if geoms.size() is 0, check if inscribed geometries are defined
        // via names of previously defined geometries.
        if( !geoms.size() ) {
            vector<string> igeoms;
            int err = i->getInput(eeg_keyword3,igeoms);
            if( err || !igeoms.size() )
                egsWarning(eeg_message1,eeg_message7);
            else {
                for(unsigned int j=0; j<igeoms.size(); j++) {
                    EGS_BaseGeometry *gj =
                        EGS_BaseGeometry::getGeometry(igeoms[j]);
                    if( !gj )
                        egsWarning(eeg_message6,igeoms[j].c_str());
                    else geoms.push_back(gj);
                }
            }
        }
        delete i;
    }
    /*
    EGS_BaseGeometry *result = fgeoms.size() ?
        new EGS_EnvelopeGeometry(g,fgeoms,geoms) :
        new EGS_EnvelopeGeometry(g,geoms);
        */
    EGS_BaseGeometry *result = new EGS_EnvelopeGeometry(g,geoms,"",indexing);
    result->setName(input);
    result->setLabels(input);
    return result;

}
Beispiel #4
0
    EGS_OCTREE_EXPORT EGS_BaseGeometry *createGeometry(EGS_Input *input) {

        EGS_Input *i;

        // check that we have an input
        if (!input) {
            egsWarning(eoctree_message1,eoctree_message2);
            return 0;
        }

        // read bounding boxes
        vector<EGS_Octree_bbox> vBox;
        while (i = input->takeInputItem(eoctree_key0)) {

            // read the bounding box minimum
            vector<EGS_Float> v;
            int err = i->getInput(eoctree_key1, v);
            if (err) {
                egsWarning(eoctree_message1, eoctree_message5);
                return 0;
            }
            if (v.size() != 3) {
                egsWarning(eoctree_message1, eoctree_message6);
                return 0;
            }
            EGS_Vector bboxMin(v[0],v[1],v[2]);

            // read the bounding box maximum
            err = i->getInput(eoctree_key2, v);
            if (err) {
                egsWarning(eoctree_message1, eoctree_message7);
                return 0;
            }
            if (v.size() != 3) {
                egsWarning(eoctree_message1, eoctree_message8);
                return 0;
            }
            EGS_Vector bboxMax(v[0],v[1],v[2]);

            // read the bounding box resolution
            vector<int> bboxRes;
            err = i->getInput(eoctree_key3, bboxRes);
            if (err) {
                egsWarning(eoctree_message1, eoctree_message9);
                return 0;
            }
            if (bboxRes.size() != 3) {
                egsWarning(eoctree_message1, eoctree_message10);
                return 0;
            }

            EGS_Octree_bbox box = EGS_Octree_bbox(bboxMin, bboxMax, bboxRes);
            vBox.push_back(box);
        }
        if (vBox.size() < 1) {
            egsWarning(eoctree_message1, eoctree_message15);
            return 0;
        }

        // read discard child option
        bool discardChild = true;
        string discard;
        if (input->getInputItem(eoctree_key5)) {
            int err = input->getInput(eoctree_key5, discard);
            if (err) {
                egsWarning(eoctree_message1, eoctree_message11);
                return 0;
            }
            if (discard.find("yes")==string::npos && discard.find("no")==string::npos) {
                egsWarning(eoctree_message1, eoctree_message12);
                return 0;
            }
            if (discard.find("no")!=string::npos) {
                discardChild = false;
            }
        }

        // read prune tree option
        bool pruneTree = true;
        string prune;
        if (input->getInputItem(eoctree_key6)) {
            int err = input->getInput(eoctree_key6, prune);
            if (err) {
                egsWarning(eoctree_message1, eoctree_message16);
                return 0;
            }
            if (prune.find("yes")==string::npos && prune.find("no")==string::npos) {
                egsWarning(eoctree_message1, eoctree_message17);
                return 0;
            }
            if (prune.find("no")!=string::npos) {
                pruneTree = false;
            }
        }

        // read and load the child geometry
        string gname;
        {
            int err = input->getInput(eoctree_key4, gname);
            if (err) {
                egsWarning(eoctree_message1, eoctree_message13);
                return 0;
            }
        }
        EGS_BaseGeometry *g = EGS_BaseGeometry::getGeometry(gname);
        if (!g) {
            egsWarning(eoctree_message1, eoctree_message14);
            return 0;
        }

        // create the octree geometry
        EGS_Octree *octree = new EGS_Octree(vBox, pruneTree, g);
        octree->setName(input);
        octree->setLabels(input);
        octree->printInfo();

        if (discardChild) {
            delete g;
        }
        return octree;
    }
Beispiel #5
0
EGS_SMART_ENVELOPE_EXPORT EGS_BaseGeometry* createGeometry(EGS_Input *input) {
    if( !input ) {
        egsWarning(eeg_message1,eeg_message2);
        return 0;
    }
    //
    // *** Base geometry
    //
    EGS_Input *i = input->takeInputItem(eeg_keyword1);
    if( !i ) {
        egsWarning(eeg_message1,eeg_message3); return 0;
    }
    EGS_Input *ig = i->takeInputItem(eeg_keyword2);
    EGS_BaseGeometry *g;
    if( ig ) { // defined inline
        g = EGS_BaseGeometry::createSingleGeometry(ig);
        delete ig;
        if( !g ) {
            egsWarning(eeg_message1,eeg_message4);
            delete i; return 0;
        }
    }
    else {  // defined via a name of a previously defined geometry
        string bgname;
        int err = i->getInput(eeg_keyword1,bgname);
        delete i;
        if( err ) {
            egsWarning(eeg_message1,eeg_message5); return 0;
        }
        g = EGS_BaseGeometry::getGeometry(bgname);
        if( !g ) {
            egsWarning(eeg_message6,bgname.c_str()); return 0;
        }
    }
    vector<SmartEnvelopeAux *> fgeoms;
    int nbase = g->regions();
    EGS_Input *ix;
    while( (ix = input->takeInputItem("inscribe geometry")) != 0 ) {
        vector<string> values;
        ix->getInput("inscribe geometry",values);
        if( values.size() < 2 ) egsWarning("createGeometry(smart envelope):"
              " %d inputs for 'inscribe geometry'? 2 or more are needed\n",values.size());
        else {
            EGS_BaseGeometry *gj = EGS_BaseGeometry::getGeometry(values[0]);
            if( !gj ) egsWarning(eeg_message6,values[0].c_str());
            else {
                SmartEnvelopeAux *aux = new SmartEnvelopeAux;
                aux->g = gj;
                aux->ireg = atoi(values[1].c_str());
                aux->type = values.size() == 3 ? atoi(values[2].c_str()) : 0;
                //egsInformation("set geometr: %s %d %d\n",values[0].c_str(),aux->ireg,aux->type);
                if( aux->ireg < 0 || aux->ireg >= nbase ) {
                    egsWarning("createGeometry(smart envelope): wrong "
                         "region index %d for inscribed geometry %s\n",
                         aux->ireg,gj->getName().c_str());
                    delete aux;
                }
                else fgeoms.push_back(aux);
            }
        }
        delete ix;
    }
    EGS_BaseGeometry *result = new EGS_SmartEnvelope(g,fgeoms,"");
    result->setName(input);
    result->setLabels(input);
    for(int j=0; j<fgeoms.size(); j++) delete fgeoms[j];
    return result;

}
EGS_RangeRejection* EGS_RangeRejection::getRangeRejection(EGS_Input *input,
        EGS_Interpolator *i_ededx, EGS_Interpolator *i_pdedx) {
    EGS_Input *rr; bool delete_it;
    if( input->isA("range rejection") ) {
        rr = input; delete_it = false;
    }
    else {
        rr = input->takeInputItem("range rejection");
        if( !rr ) return 0;
        delete_it = true;
    }
    int iaux; int err = rr->getInput("rejection",iaux);
    EGS_RangeRejection *result = 0;
    if( !err && iaux > 0 ) {
        result = new EGS_RangeRejection;
        if( iaux == 1 )
            result->type = RangeDiscard;
        else {
            result->type = RussianRoulette;
            result->probi = iaux;
        }
        EGS_Float aux; err = rr->getInput("Esave",aux);
        if( !err && aux >= 0 ) result->Esave = aux;
        string cavity_geometry;
        err = rr->getInput("cavity geometry",cavity_geometry);
        if( !err ) {
            result->cgeom = EGS_BaseGeometry::getGeometry(cavity_geometry);
            if( !result->cgeom ) egsWarning("\n\n********** no geometry named"
                       " %s exists => using region-by-region rejection only\n");
        }
        if( result->Esave <= the_useful->prm && result->type == RangeDiscard ) {
            egsWarning("\n\n********* rr_flag = 1 but Esave = 0 =>"
                         " not using range rejection\n\n");
            delete result; result = 0;
        }
        if( result && result->type != None && result->cgeom ) {
            string rej_medium; int irej_medium = -1;
            err = rr->getInput("rejection range medium",rej_medium);
            if( !err ) {
                int imed = EGS_BaseGeometry::getMediumIndex(rej_medium);
                if( imed < 0 ) egsWarning("\n\n*********** no medium"
                    " with name %s initialized => using region-by-region rejection only\n",
                    rej_medium.c_str());
                else irej_medium = imed;
            }
            if( irej_medium < 0 ) { result->cgeom = 0; result->type = RangeDiscard; }
            else {
                //
                // *** prepare an interpolator for the electron range
                //     in the range rejection medium
                //
                int i = irej_medium; // save some typing
                EGS_Float log_emin = i_ededx[i].getXmin();
                EGS_Float log_emax = i_ededx[i].getXmax();
                int nbin = 512;
                EGS_Float dloge = (log_emax - log_emin)/nbin;
                EGS_Float *erange = new EGS_Float [nbin];
                EGS_Float *prange = new EGS_Float [nbin];
                erange[0] = 0; prange[0] = 0;
                EGS_Float ededx_old = i_ededx[i].interpolate(log_emin);
                EGS_Float pdedx_old = i_pdedx[i].interpolate(log_emin);
                EGS_Float Eold = exp(log_emin);
                EGS_Float efak = exp(dloge);
                for(int j=1; j<nbin; j++) {
                    EGS_Float elke = log_emin + dloge*j;
                    EGS_Float E = Eold*efak;
                    EGS_Float ededx = i_ededx[i].interpolate(elke);
                    EGS_Float pdedx = i_pdedx[i].interpolate(elke);
                    if( ededx < ededx_old )
                    erange[j] = erange[j-1]+1.02*(E-Eold)/ededx;
                    else
                    erange[j] = erange[j-1]+1.02*(E-Eold)/ededx_old;
                    if( pdedx < pdedx_old )
                    prange[j] = prange[j-1]+1.02*(E-Eold)/pdedx;
                    else
                    prange[j] = prange[j-1]+1.02*(E-Eold)/pdedx_old;
                    Eold = E; ededx_old = ededx; pdedx_old = pdedx;
                }
                result->erange.initialize(nbin,log_emin,log_emax,erange);
                result->prange.initialize(nbin,log_emin,log_emax,prange);
            }
        }
    }
    if( delete_it ) delete rr;
    return result;
}