//#####################################################################
// Function Simplices_On_Subsimplex
//#####################################################################
template<int d> template<int d2> void SIMPLEX_MESH<d>::
Simplices_On_Subsimplex(const VECTOR<int,d2>& subsimplex_nodes,ARRAY<int>& simplices_on_subsimplex) const
{
assert(incident_elements);
const ARRAY<int>& incident=(*incident_elements)(subsimplex_nodes[1]);
VECTOR<int,d2-1> other_nodes=subsimplex_nodes.Remove_Index(1);
for(int i=1;i<=incident.m;i++){
int simplex=incident(i);
if(Nodes_In_Simplex(other_nodes,simplex)) simplices_on_subsimplex.Append(simplex);}
}
void
check_edge_facet_intersections<GRID,GEOM,GT>::
find_non_incident_facet_edge_pairs()
{
// for each facet of each cell, we find edges of the same cell
// not incident to the facet.
// It suffices to do so for each archetype once.
for(typename gt::archetype_iterator
a = TheGrid().BeginArchetype();
a != TheGrid().EndArchetype();
++a) {
arch_non_incident_edges.push_back(arch_cell_edge_range(*a));
for(typename agt::CellIterator aC(*a); ! aC.IsDone(); ++aC) {
arch_non_incident_edges.back()[*aC] = arch_edge_range(*a);
for(typename agt::EdgeIterator aE(*a); !aE.IsDone(); ++aE)
if(! incident((*aE).V1(), *aC) && ! incident((*aE).V2(), *aC) )
arch_non_incident_edges.back()[*aC].push_back(*aE);
}
}
}
//=============================================================================
StatusCode IncidentListenerTestAlg::initialize() {
StatusCode sc = GaudiAlgorithm::initialize();
if (sc.isFailure()) return sc;
// get a the incident service
m_incSvc = svc<IIncidentSvc>("IncidentSvc",true);
// instantiate listeners
m_listener[0] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 0",serviceLocator()));
m_listener[1] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 1",serviceLocator(),3));
m_listener[2] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 2",serviceLocator()));
m_listener[3] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Listener 3",serviceLocator()));
m_listener[4] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("EventBoundary",serviceLocator()));
m_listener[5] =
std::auto_ptr<IncidentListenerTest>(new IncidentListenerTest("Generic Listener",serviceLocator()));
info() << "Registering incident listeners" << endmsg;
const bool rethrow = false;
const bool singleShot = true;
const long priority = -10;
m_incSvc->addListener(m_listener[3].get(),incident(),priority,rethrow,singleShot);
m_incSvc->addListener(m_listener[0].get(),incident());
m_incSvc->addListener(m_listener[1].get(),incident());
m_incSvc->addListener(m_listener[2].get(),incident());
m_incSvc->addListener(m_listener[4].get(),IncidentType::BeginEvent);
m_incSvc->addListener(m_listener[4].get(),IncidentType::EndEvent);
m_incSvc->addListener(m_listener[5].get());
return StatusCode::SUCCESS;
}
SpectrumCoef_d MERLMeasured::Sample(const Vector3D_d &i_incident, Vector3D_d &o_exitant, const Point2D_d &i_sample, double &o_pdf) const
{
ASSERT(i_sample[0]>=0.0 && i_sample[0]<=1.0);
ASSERT(i_sample[1]>=0.0 && i_sample[1]<=1.0);
ASSERT(i_incident.IsNormalized());
if (i_incident[2] >= 0.0)
return mp_merl_measured_data->Sample(i_incident, o_exitant, i_sample, o_pdf);
else
{
Vector3D_d incident(i_incident[0], i_incident[1], -i_incident[2]);
SpectrumCoef_d ret = mp_merl_measured_data->Sample(incident, o_exitant, i_sample, o_pdf);
o_exitant[2] *= -1.0;
return ret;
}
}
double MERLMeasured::PDF(const Vector3D_d &i_incident, const Vector3D_d &i_exitant) const
{
ASSERT(i_incident.IsNormalized());
ASSERT(i_exitant.IsNormalized());
if (i_incident[2]*i_exitant[2] < 0.0)
return 0.0;
else
if (i_incident[2] >= 0.0)
return mp_merl_measured_data->PDF(i_incident, i_exitant);
else
{
Vector3D_d incident(i_incident[0], i_incident[1], -i_incident[2]);
Vector3D_d exitant(i_exitant[0], i_exitant[1], -i_exitant[2]);
return mp_merl_measured_data->PDF(incident, exitant);
}
}
SpectrumCoef_d MERLMeasured::Evaluate(const Vector3D_d &i_incident, const Vector3D_d &i_exitant) const
{
ASSERT(i_incident.IsNormalized());
ASSERT(i_exitant.IsNormalized());
if (i_incident[2]*i_exitant[2] < 0.0)
return SpectrumCoef_d();
else
if (i_incident[2] >= 0.0)
return mp_merl_measured_data->GetBRDF(i_incident, i_exitant);
else
{
Vector3D_d incident(i_incident[0], i_incident[1], -i_incident[2]);
Vector3D_d exitant(i_exitant[0], i_exitant[1], -i_exitant[2]);
return mp_merl_measured_data->GetBRDF(incident, exitant);
}
}
Vector Graph::incident(long int vertex, NeighborMode mode) const {
Vector result;
incident(&result, vertex, mode);
return result;
}
//=============================================================================
StatusCode IncidentListenerTestAlg::execute() {
info() << "Firing incident" << endmsg;
m_incSvc->fireIncident(Incident(name(),incident()));
return StatusCode::SUCCESS;
}
