double interpolate(Healpix_Map<double>* map, double theta, double phi) {
pointing ptg = pointing(theta, phi);
fix_arr<int,4> pix = fix_arr<int,4>();
fix_arr<double,4> wgt = fix_arr<double,4>();
map->get_interpol(ptg, pix, wgt);
return wgt[0]*(*map)[pix[0]] + wgt[1]*(*map)[pix[1]]
+ wgt[2]*(*map)[pix[2]] + wgt[3]*(*map)[pix[3]];
}
FGThruster::FGThruster(FGFDMExec *FDMExec, Element *el, int num ): FGForce(FDMExec)
{
Element* thruster_element = el->GetParent();
Element* element;
FGColumnVector3 location, orientation, pointing;
Type = ttDirect;
SetTransformType(FGForce::tCustom);
Name = el->GetAttributeValue("name");
GearRatio = 1.0;
ReverserAngle = 0.0;
Thrust = 0.0;
EngineNum = num;
PropertyManager = FDMExec->GetPropertyManager();
// Determine the initial location and orientation of this thruster and load the
// thruster with this information.
element = thruster_element->FindElement("location");
if (element) location = element->FindElementTripletConvertTo("IN");
else cerr << fgred << " No thruster location found." << reset << endl;
SetLocation(location);
string property_name, base_property_name;
base_property_name = CreateIndexedPropertyName("propulsion/engine", EngineNum);
element = thruster_element->FindElement("pointing");
if (element) {
// This defines a fixed nozzle that has no public interface property to gimbal or reverse it.
pointing = element->FindElementTripletConvertTo("RAD"); // The specification of RAD here is superfluous,
// and simply precludes a conversion.
mT.InitMatrix();
mT(1,1) = pointing(1);
mT(2,1) = pointing(2);
mT(3,1) = pointing(3);
} else {
element = thruster_element->FindElement("orient");
if (element) orientation = element->FindElementTripletConvertTo("RAD");
SetAnglesToBody(orientation);
property_name = base_property_name + "/pitch-angle-rad";
PropertyManager->Tie( property_name.c_str(), (FGForce *)this, &FGForce::GetPitch, &FGForce::SetPitch);
property_name = base_property_name + "/yaw-angle-rad";
PropertyManager->Tie( property_name.c_str(), (FGForce *)this, &FGForce::GetYaw, &FGForce::SetYaw);
if (el->GetName() == "direct") // this is a direct thruster. At this time
// only a direct thruster can be reversed.
{
property_name = base_property_name + "/reverser-angle-rad";
PropertyManager->Tie( property_name.c_str(), (FGThruster *)this, &FGThruster::GetReverserAngle,
&FGThruster::SetReverserAngle);
}
}
Debug(0);
}
/***********************************************************************//**
* @brief Create output observation container.
*
* Creates an output observation container that combines all input CTA
* observation into a single cube-style observation. All non CTA observations
* present in the observation container are kept. The method furthermore
* conserves any response information in case that a single CTA observation
* is provided. This supports the original binned analysis.
***************************************************************************/
void ctbin::obs_cube(void)
{
// If we have only a single CTA observation in the container, then
// keep that observation and just attach the event cube to it. Reset
// the filename, otherwise we still will have the old event filename
// in the log file.
if (m_obs.size() == 1) {
// Attach event cube to CTA observation
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[0]);
if (obs != NULL) {
obs->events(this->cube());
obs->eventfile("");
}
}
// ... otherwise put a single CTA observation in container
else {
// Allocate observation container
GObservations container;
// Allocate CTA observation.
GCTAObservation obs;
// Attach event cube to CTA observation
obs.events(this->cube());
// Set map centre as pointing
GSkyPixel pixel(0.5*double(m_cube.nx()), 0.5*double(m_cube.ny()));
GSkyDir centre = m_cube.pix2dir(pixel);
GCTAPointing pointing(centre);
// Compute deadtime correction
double deadc = (m_ontime > 0.0) ? m_livetime / m_ontime : 0.0;
// Set CTA observation attributes
obs.pointing(pointing);
obs.obs_id(0);
obs.ra_obj(centre.ra_deg()); //!< Dummy
obs.dec_obj(centre.dec_deg()); //!< Dummy
obs.ontime(m_ontime);
obs.livetime(m_livetime);
obs.deadc(deadc);
// Set models in observation container
container.models(m_obs.models());
// Append CTA observation
container.append(obs);
// Copy over all remaining non-CTA observations
for (int i = 0; i < m_obs.size(); ++i) {
GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
if (obs == NULL) {
container.append(*m_obs[i]);
}
}
// Set observation container
m_obs = container;
} // endelse: there was not a single CTA observation
// Return
return;
}
