---

LayeredMedium.cxx

Go to the documentation of this file.

//  $Id: LayeredMedium.cxx,v 1.5 2001/10/06 14:18:52 burnett Exp $

#include "gismo/LayeredMedium.h"

#include "geometry/Surface.h"
#include "geometry/Ray.h"
#include <cassert>
//      LayeredMedium::Volume implementation

LayeredMedium::Volume::Volume(int n)
: ::Volume(n)
{}
void
LayeredMedium::Volume::setOffsets(double inner, double outer)
{
    surface(0).setOffset(-inner);
    surface(1).setOffset(outer);
}


//      LayeredMedium::Slice implementation
LayeredMedium::Slice::Slice(LayeredMedium& mother, int index)
: ::Volume(0)   // don't own any surfaces
, m_mother(mother)
, m_index(index)
{}

LayeredMedium::Slice::~Slice()
{}

const Volume& LayeredMedium::Slice::setMotherVolume()const
{
    LayeredMedium* mom = const_cast<LayeredMedium*>(&m_mother);
    LayeredMedium::Volume* mom_vol= mom->m_vol;

    // Since we share the main volume, adjust the inner and outer surface, use it
    mom_vol->setOffsets( mom->m_offset[m_index], mom->m_offset[m_index+1]);
    return *mom_vol;
}

const Volume& LayeredMedium::Slice::resetMotherVolume()const
{
    LayeredMedium* mom = const_cast<LayeredMedium*>(&m_mother);
    LayeredMedium::Volume* mom_vol= mom->m_vol;
    
    // Since we share the main volume, adjust the inner and outer surface, use it
    mom_vol->setOffsets( mom->m_offset[0], mom->m_offset[mom->size()]);
    return *mom_vol;
}

double
LayeredMedium::Slice::distanceToLeave(  const Ray& r, double dmax) const
{
    //CEnter1("LayeredMedium::Slice::distanceToLeave", "at z=%g\n", r.position().z());
    // get (non-const) volume to manipulate surfaces
    LayeredMedium* mom = const_cast<LayeredMedium*>(&m_mother);
    LayeredMedium::Volume* mom_vol= mom->m_vol;

    // Since we share the main volume, adjust the inner and outer surface, use it
    mom_vol->setOffsets( mom->m_offset[m_index], mom->m_offset[m_index+1]);
    double d = mom_vol->distanceToLeave( r, dmax);
    mom_vol->setOffsets(mom->m_offset[0], mom->m_offset[mom->size()]);

    // if we really left, identify the surface, and our index,
    //  for use by LayeredMedium::distanceToLeave
    if( d== dmax ){
        mom->m_last_boundary = -1;
        mom->m_select_index = -1;
    }else {
        mom->m_last_boundary = lastBoundaryIndex();
        mom->m_select_index = m_index;
    }
    return d;
}
void
LayeredMedium::Slice::printOn(std::ostream& out)const
{
    // get (non-const) volume to manipulate surfaces
    LayeredMedium* mom = const_cast<LayeredMedium*>(&m_mother);
    LayeredMedium::Volume* mom_vol= mom->m_vol;


    mom_vol->setOffsets( mom->m_offset[m_index], mom->m_offset[m_index+1]);
    mom_vol->printOn(out);
    mom_vol->setOffsets(mom->m_offset[0], mom->m_offset[mom->size()]);
}

//      LayeredMedium implementation
LayeredMedium::LayeredMedium(Medium* mother, int num_surfaces, double inner_offset)
: CompositeMedium(mother, (Shape*)0)
, m_vol(new Volume(num_surfaces))
, m_select_index(-1)
, m_last_boundary(-1)
{
    setVolume(m_vol);
    m_offset.push_back(inner_offset); // first offset, corresponding to inner surface
}
LayeredMedium::~LayeredMedium()
{}


Medium &
LayeredMedium::addLayer(Medium * inner_medium, double thickness)
{
    // following conditions enforced by subclass
    assert(inner_medium->parent() == this);
    assert(&(inner_medium->volume()) == 0);

    m_offset.push_back( m_offset[size()-1]+thickness);

    inner_medium->setVolume( new LayeredMedium::Slice(*this, size()-1 ) );
    m_vol->setOffsets(m_offset[0], m_offset[size()]);
    return *inner_medium;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                 Tracking
double
LayeredMedium::distanceToEnter(const Ray& r, const Medium*& m, double t)const
{
    // override this to select a Layer to enter.
    // first, do we enter the overall volume?
    double d = Medium::distanceToEnter(r,m,t);

    if( d != FLT_MAX ){
        m = select(r.position(d));
    }
    return d;

}

double
LayeredMedium::distanceToLeave(const Ray& r, const Medium*& nextMedium
                               , double /* maxDist*/)const
{
    double distance = 0;

        if(r.getFlag() == 0){
        LayeredMedium* me = const_cast<LayeredMedium*>(this);
                me->m_select_index = -1;
                me->m_last_boundary = -1;
        }
                
        if( m_select_index==-1)
    {   // here if returning to a previous interaction. Should be inside a slice!
        nextMedium =select(r.position());
        return 0;
    }

    int sel = m_select_index;
    if( m_last_boundary ==0 && sel >0) {
        nextMedium = operator[](--sel);
    }else if( (m_last_boundary==1)
              && ( sel < static_cast<int>(size()-1) )   ) {
        nextMedium = operator[](++sel);
    }else {
        nextMedium = parent();
#ifdef _DEBUG
        int check = m_vol->getBoundaryIndex(r.position()); // verify on boundary
#endif //_DEBUG
        sel = -1;
    }
    // update tags
    LayeredMedium* me = const_cast<LayeredMedium*>(this);
    me->m_last_boundary=-1;
    me->m_select_index=sel;
    return distance;
}
const Surface&
LayeredMedium::referenceSurface()const
{
    return m_vol->surface(0);
}
const Medium*
LayeredMedium::select(const Point& x)const
{
    // assume point is within over-all volume, find out which division
   // CEnter1("LayeredMedium::select", "point.z= %g\n", x.z() );
    LayeredMedium* me = const_cast<LayeredMedium*>(this);

    double d = referenceSurface().how_near(x);
    unsigned int i;
    for(  i=0; i< size()-1; i++) {
        if( m_offset[i+1]>= d) break;
    }
    me->m_select_index = i;
    me->m_last_boundary=-1;
    return operator[](i);
}
const Medium*
LayeredMedium::inside(const Point& x)const
{
    if( ! volume().inside(x) ) return parent();
    const Medium* m = select(x);
    LayeredMedium* me = const_cast<LayeredMedium*>(this);
    me->m_select_index = -1;

    return m;
}

---