#include "Schedule.h"
#include <SkySource.h>
#include <slamac.h>

using namespace Schedule;

CSubScanBinder::CSubScanBinder(Antenna::TTrackingParameters * const primary,Antenna::TTrackingParameters * const secondary,
		MinorServo::MinorServoScan * const servo,Receivers::TReceiversParameters * const receivers,
		Management::TSubScanConfiguration * const subScanConf,CConfiguration* config):
 m_primary(primary),m_secondary(secondary),m_servo(servo),m_receivers(receivers),m_subScanConf(subScanConf),m_own(false),m_config(config)
{
	init();
}

CSubScanBinder::CSubScanBinder(CConfiguration* config,bool dispose): m_primary(NULL), m_secondary(NULL), m_servo(NULL),
		m_receivers(NULL),m_own(dispose), m_config(config)
{
	m_primary=new Antenna::TTrackingParameters;
	m_secondary=new Antenna::TTrackingParameters;
	m_servo=new MinorServo::MinorServoScan;
	m_receivers=new Receivers::TReceiversParameters;
	m_subScanConf=new Management::TSubScanConfiguration;
	init();
}

CSubScanBinder::~CSubScanBinder()
{
	if (m_own) {
		dispose();
	}
}

void CSubScanBinder::dispose()
{
	if (m_primary) delete m_primary;
	if (m_secondary) delete m_secondary;
	if (m_servo) delete m_servo;
	if (m_receivers) delete m_receivers;
	if (m_subScanConf) delete m_subScanConf;
}

void CSubScanBinder::addOffsets(const double& lonOff,const double& latOff,const Antenna::TCoordinateFrame& frame)
{
	m_primary->latitudeOffset=latOff;
	m_primary->longitudeOffset=lonOff;
	m_primary->applyOffsets=true;
	m_primary->offsetFrame=frame;
	if ((fabs(lonOff)>0.0000001) || (fabs(latOff)>0.0000001)) {
		m_subScanConf->signal=Management::MNG_SIGNAL_REFERENCE;
	}
}

void CSubScanBinder::addRadialvelocity(const Antenna::TReferenceFrame& VradFrame,const Antenna::TVradDefinition& VradDefinition,const double& RadialVelocity)
{
	m_primary->VradFrame=VradFrame;
	m_primary->VradDefinition=VradDefinition;
	m_primary->RadialVelocity=RadialVelocity;
}

void CSubScanBinder::peaker(const IRA::CString& axis,const double& span,const ACS::TimeInterval& duration,const Antenna::TTrackingParameters * const sec)
{
	double antennaSpan,bdf;
	Management::TScanAxis axisCode;
	Antenna::TsubScanGeometry geom;
	Antenna::TsubScanDirection direction;
	if (!m_config) {
		bdf=0.0; // do not associate a movement in the telescope.....this corresponds to a simple tracking of the source
	}
	else {
		axisCode=m_config->getAxisFromServoName(axis);
		bdf=m_config->getBDFfromAxis(axisCode)/3600.0; //degrees per mm
		bdf*=DD2R; // radians per mm
		geom=m_config->getScanGeometryFromAxis(axisCode);
	}
	antennaSpan=span*bdf;
	if (antennaSpan>=0) {
		direction=Antenna::SUBSCAN_INCREASE;
	}
	else {
		direction=Antenna::SUBSCAN_INCREASE;
		antennaSpan*=-1.0;
	}
	if (antennaSpan>0) { // this case is when a bdf is not null so the secondary movement is an otfC 
		OnTheFlyC(Antenna::ANT_EQUATORIAL,geom,Antenna::ANT_HORIZONTAL,direction,antennaSpan,duration,sec);
	}
	else {
		if (sec==NULL) { // in this case the current target is kept!
			m_primary->secondary=true;
			m_secondary->type=Antenna::ANT_NONE;
		}
		else {
			copyPrimaryAntenaTrack(sec);
			findTarget(sec); //target is defined by the secondary track
		}
	}

    /*second.secondary=false; second.paramNumber=0; second.applyOffsets=false; second.type=Antenna::ANT_NONE; second.enableCorrection=true;
    prim.type=Antenna::ANT_NONE;
    prim.paramNumber=0;
    prim.secondary=true;
    prim.applyOffsets=true;*/

   m_servo->is_empty_scan=false;
   m_servo->axis_code=CORBA::string_dup((const char *)axis);
   m_servo->range=span;
   m_servo->total_time=duration;
	m_receivers->dummy=0;
	m_subScanConf->signal=Management::MNG_SIGNAL_NONE;
}

void CSubScanBinder::OnTheFlyC(const Antenna::TCoordinateFrame& coordFrame,const Antenna::TsubScanGeometry& geometry,
	const Antenna::TCoordinateFrame& subScanFrame,const Antenna::TsubScanDirection& direction,
	const double& span,const ACS::TimeInterval& subScanDuration,const Antenna::TTrackingParameters * const sec)
{
	m_primary->secondary=true;
	m_primary->enableCorrection=true;
	m_primary->type=Antenna::ANT_OTF;
	m_primary->section=Antenna::ACU_NEUTRAL;
	m_primary->paramNumber=0;
	m_primary->otf.lon1=m_primary->otf.lat1=0.0; // this will be replaced by the antennaboss component
	m_primary->otf.description=Antenna::SUBSCAN_CENTER;
	m_primary->otf.subScanDuration=subScanDuration;
	m_primary->otf.coordFrame=coordFrame;
	m_primary->otf.direction=direction;
	m_primary->otf.geometry=geometry;
	m_primary->otf.subScanFrame=subScanFrame;
	if (m_primary->otf.geometry==Antenna::SUBSCAN_CONSTLON) {
		m_primary->otf.lat2=span;
		m_primary->otf.lon2=0.0;
	}
	else {
		m_primary->otf.lat2=0.0;
		m_primary->otf.lon2=span;
	}
	addSecondaryAntennaTrack(sec);
	findTarget(m_primary);
	m_servo->is_empty_scan=true;
	m_servo->axis_code=CORBA::string_dup("");
	m_servo->range=0;
	m_servo->total_time=0;
	m_receivers->dummy=0;
	m_subScanConf->signal=Management::MNG_SIGNAL_NONE;
}

void CSubScanBinder::skydip(const double& lat1,const double& lat2,const ACS::TimeInterval& duration,
		const Antenna::TTrackingParameters * const sec)
{
	//the real target name, as well as the m_primary->secondary=true clause, will be set by the call to addSecondaryAntennaTrack();
	if (lat1>lat2) {
		OnTheFly("skydip",0.0,lat1,0.0,lat2,Antenna::ANT_HORIZONTAL,Antenna::SUBSCAN_CONSTLON,
				Antenna::ANT_HORIZONTAL,Antenna::SUBSCAN_STARTSTOP,Antenna::SUBSCAN_DECREASE,duration);
	}
	else {
		OnTheFly("skydip",0.0,lat2,0.0,lat1,Antenna::ANT_HORIZONTAL,Antenna::SUBSCAN_CONSTLON,
				Antenna::ANT_HORIZONTAL,Antenna::SUBSCAN_STARTSTOP,Antenna::SUBSCAN_INCREASE,duration);
	}
	addSecondaryAntennaTrack(sec);
	findTarget(sec); // note: sec is the correct argument, as we treat skydip as a sidereal when determining the target.
	m_primary->enableCorrection=false;
	m_servo->is_empty_scan=true;
	m_servo->axis_code=CORBA::string_dup("");
	m_servo->range=0;
	m_servo->total_time=0;
	m_receivers->dummy=0;
	m_subScanConf->signal=Management::MNG_SIGNAL_NONE;	
}

void CSubScanBinder::OnTheFly(
		const IRA::CString& target,
		const double& lon1,const double& lat1,const double& lon2,const double& lat2,
		const Antenna::TCoordinateFrame& coordFrame,const Antenna::TsubScanGeometry& geometry,
		const Antenna::TCoordinateFrame& subScanFrame,const Antenna::TsubScanDescription& description,
		const Antenna::TsubScanDirection& direction,const ACS::TimeInterval& subScanDuration)
{
	m_primary->secondary=false;
	m_primary->enableCorrection=true;
	m_primary->type=Antenna::ANT_OTF;
	m_primary->section=Antenna::ACU_NEUTRAL; // no support for section selection in schedule right now
	m_primary->paramNumber=0;
	m_primary->targetName=CORBA::string_dup((const char *)target);
	m_primary->otf.subScanDuration=subScanDuration;
	m_primary->otf.description=description;
	m_primary->otf.lat1=lat1;
	m_primary->otf.lat2=lat2;
	m_primary->otf.lon1=lon1;
	m_primary->otf.lon2=lon2;
	m_primary->otf.coordFrame=coordFrame;
	m_primary->otf.subScanFrame=subScanFrame;
	m_primary->otf.geometry=geometry;
	m_primary->otf.direction=direction;
	m_primary->latitudeOffset=m_primary->longitudeOffset=0.0;
	m_primary->applyOffsets=false;
	findTarget(m_primary);
	m_secondary->secondary=false; m_secondary->paramNumber=0; m_secondary->applyOffsets=false;
	m_secondary->type=Antenna::ANT_NONE; m_secondary->enableCorrection=true;
	m_servo->is_empty_scan=true;
	m_servo->axis_code=CORBA::string_dup("");
	m_servo->range=0;
	m_servo->total_time=0;
	m_receivers->dummy=0;
	m_subScanConf->signal=Management::MNG_SIGNAL_NONE;
}

void CSubScanBinder::lonOTF(const Antenna::TCoordinateFrame& scanFrame,const double& span,const ACS::TimeInterval& duration)
{
	m_secondary->secondary=false; m_secondary->paramNumber=0; m_secondary->applyOffsets=false;
	m_secondary->type=Antenna::ANT_NONE; m_secondary->enableCorrection=true;
	m_primary->type=Antenna::ANT_OTF;
	m_primary->otf.lon1=0.0; m_primary->otf.lat1=0.0; // they will be set by internal antenna engine
	if (scanFrame!=Antenna::ANT_HORIZONTAL) {
		m_primary->otf.coordFrame=scanFrame;
		m_primary->otf.subScanFrame=scanFrame;
	}
	else {
		m_primary->otf.coordFrame=Antenna::ANT_EQUATORIAL;
		m_primary->otf.subScanFrame=Antenna::ANT_HORIZONTAL;
	}
	m_primary->otf.description=Antenna::SUBSCAN_CENTER; // a must !!!!!
	m_primary->otf.subScanDuration=duration;
	m_primary->otf.direction=Antenna::SUBSCAN_INCREASE; // this is
	m_primary->otf.geometry=Antenna::SUBSCAN_CONSTLAT; // a must !!!!!
	m_primary->otf.lon2=span;
	m_primary->otf.lat2=0.0;
	m_primary->applyOffsets=false;  // no offset for this scan!
	m_primary->secondary=true;  // force the engine to look for the secondary track, or if the secondary is not set (this case) to use the previously commanded track
	m_primary->targetName=CORBA::string_dup("otf"); // not strictly necessary as the system will take the last commanded name
	m_primary->section=Antenna::ACU_NEUTRAL;
	m_primary->enableCorrection=true;
   m_servo->is_empty_scan=true;
   m_servo->axis_code=CORBA::string_dup("");
   m_servo->range=0;
   m_servo->total_time=0;
   m_receivers->dummy=0;
   m_subScanConf->signal=Management::MNG_SIGNAL_NONE;
	// The other subsystems can stay with defaults
}

void CSubScanBinder::latOTF(const Antenna::TCoordinateFrame& scanFrame,const double& span,const ACS::TimeInterval& duration)
{
	m_secondary->secondary=false; m_secondary->paramNumber=0; m_secondary->applyOffsets=false;
	m_secondary->type=Antenna::ANT_NONE; m_secondary->enableCorrection=true;
	m_primary->type=Antenna::ANT_OTF;
	m_primary->otf.lon1=0.0; // they will be set by internal engine
	m_primary->otf.lat1=0.0;
	if (scanFrame!=Antenna::ANT_HORIZONTAL) {
		m_primary->otf.coordFrame=scanFrame;
		m_primary->otf.subScanFrame=scanFrame;
	}
	else {
		m_primary->otf.coordFrame=Antenna::ANT_EQUATORIAL;
		m_primary->otf.subScanFrame=Antenna::ANT_HORIZONTAL;
	}
	m_primary->otf.description=Antenna::SUBSCAN_CENTER; // a must !!!!!
	m_primary->otf.subScanDuration=duration;
	m_primary->otf.direction=Antenna::SUBSCAN_INCREASE;
	m_primary->otf.geometry=Antenna::SUBSCAN_CONSTLON; // a must !!!!!
	m_primary->otf.lon2=0.0;
	m_primary->otf.lat2=span;
	m_primary->applyOffsets=false;  // no offset for this scan!
	m_primary->secondary=true;  // force the engine to look for the secondary track, or if the secondary is not set (this case) to use the previously commanded track
	m_primary->targetName=CORBA::string_dup("otf"); // not strictly necessary as the system will take the last commanded name
	m_primary->section=Antenna::ACU_NEUTRAL;
	m_primary->enableCorrection=true;
   m_servo->is_empty_scan=true;
   m_servo->axis_code=CORBA::string_dup("");
   m_servo->range=0;
   m_servo->total_time=0;
   m_receivers->dummy=0; 
   m_subScanConf->signal=Management::MNG_SIGNAL_NONE;
	// The other subsystems can stay with defaults
}

void CSubScanBinder::sidereal(const char * targetName,const Antenna::TCoordinateFrame& frame,double *parameters,const long& paramNumber,
		const Antenna::TSystemEquinox& eq)
{
	m_secondary->secondary=false; m_secondary->paramNumber=0; m_secondary->applyOffsets=false;
	m_secondary->type=Antenna::ANT_NONE; m_secondary->enableCorrection=true;
	m_primary->type=Antenna::ANT_SIDEREAL;
	m_primary->targetName=CORBA::string_dup(targetName);
	m_primary->enableCorrection=true;
	m_primary->paramNumber=paramNumber;
	m_primary->frame=frame;
	for (long i=0;i<paramNumber;i++) m_primary->parameters[i]=parameters[i];
	m_primary->equinox=eq;
	m_primary->section=Antenna::ACU_NEUTRAL; // no support, yet!
	m_primary->secondary=false;
	m_primary->applyOffsets=false;
	m_primary->latitudeOffset=m_primary->longitudeOffset=0.0;
	m_primary->offsetFrame=Antenna::ANT_EQUATORIAL; // place holder in this case
	m_primary->VradFrame=Antenna::ANT_UNDEF_FRAME;
	m_primary->VradDefinition=Antenna::ANT_UNDEF_DEF;
	m_primary->RadialVelocity=0.0;
	findTarget(m_primary); //target is defined by the primary track
   m_servo->is_empty_scan=true;
   m_servo->axis_code=CORBA::string_dup("");
   m_servo->range=0;
   m_servo->total_time=0;
   m_receivers->dummy=0;
   m_subScanConf->signal=Management::MNG_SIGNAL_SIGNAL;
}

void CSubScanBinder::sidereal(const char * targetName,const double& ra,const double& dec,const Antenna::TSystemEquinox& eq,const Antenna::TSections& section)
{
	m_secondary->secondary=false; m_secondary->paramNumber=0; m_secondary->applyOffsets=false;
	m_secondary->type=Antenna::ANT_NONE; m_secondary->enableCorrection=true;
	m_primary->type=Antenna::ANT_SIDEREAL;
	m_primary->parameters[0]=ra;
	m_primary->parameters[1]=dec;
	m_primary->paramNumber=2;
	m_primary->frame=Antenna::ANT_EQUATORIAL;
	m_primary->equinox=eq;
	m_primary->section=section;
	m_primary->targetName=CORBA::string_dup(targetName);
	m_primary->secondary=false;
	m_primary->applyOffsets=false;
	m_primary->enableCorrection=true;
	findTarget(m_primary);
   m_servo->is_empty_scan=true;
   m_servo->axis_code=CORBA::string_dup("");
   m_servo->range=0;
   m_servo->total_time=0;
   m_receivers->dummy=0; 
   m_subScanConf->signal=Management::MNG_SIGNAL_SIGNAL;
	// The other subsystems can stay with defaults
}

void CSubScanBinder::moon()
{
	m_secondary->type=Antenna::ANT_NONE;
	m_secondary->secondary=false;
	m_secondary->applyOffsets=false;
	m_secondary->paramNumber=0;
	m_secondary->enableCorrection=true;
	m_primary->type=Antenna::ANT_MOON;
	m_primary->secondary=false;
	m_primary->targetName=CORBA::string_dup("Moon");
	m_primary->applyOffsets=false;
	m_primary->section=Antenna::ACU_NEUTRAL;
	m_primary->enableCorrection=true;
	findTarget(m_primary);
   m_servo->is_empty_scan=true;
   m_servo->axis_code=CORBA::string_dup("");
   m_servo->range=0;
   m_servo->total_time=0;
	m_receivers->dummy=0;   
   m_subScanConf->signal=Management::MNG_SIGNAL_SIGNAL;
	// The other subsystems can stay with defaults
}

void CSubScanBinder::track(const char *targetName)
{
	m_secondary->type=Antenna::ANT_NONE;
	m_secondary->secondary=false;
	m_secondary->applyOffsets=false;
	m_secondary->paramNumber=0;
	m_secondary->enableCorrection=true;
	m_primary->type=Antenna::ANT_SIDEREAL;
	m_primary->secondary=false;
	m_primary->paramNumber=0;
	m_primary->applyOffsets=false;
	m_primary->targetName=CORBA::string_dup(targetName);
	m_primary->section=Antenna::ACU_NEUTRAL;
	m_primary->enableCorrection=true;
	findTarget(m_primary);
   m_servo->is_empty_scan=true;
   m_servo->axis_code=CORBA::string_dup("");
   m_servo->range=0;
   m_servo->total_time=0;
   m_receivers->dummy=0;
   m_subScanConf->signal=Management::MNG_SIGNAL_SIGNAL;
	// The other subsystems can stay with defaults
}

void CSubScanBinder::goTo(const double& az,const double& el)
{
	m_secondary->secondary=false; m_secondary->paramNumber=0; m_secondary->applyOffsets=false;
	m_secondary->type=Antenna::ANT_NONE; m_secondary->enableCorrection=true;
	m_primary->type=Antenna::ANT_SIDEREAL;
	m_primary->parameters[0]=az;
	m_primary->parameters[1]=el;
	m_primary->paramNumber=2;
	m_primary->frame=Antenna::ANT_HORIZONTAL;
	m_primary->equinox=Antenna::ANT_APPARENT;
	m_primary->section=Antenna::ACU_NEUTRAL;
	m_primary->targetName=CORBA::string_dup("BeamPark");
	m_primary->secondary=false;
	m_primary->applyOffsets=false;
	m_primary->enableCorrection=false;
   m_servo->is_empty_scan=true;
   m_servo->axis_code=CORBA::string_dup("");
   m_servo->range=0;
   m_servo->total_time=0;
	m_receivers->dummy=0;  
   m_subScanConf->signal=Management::MNG_SIGNAL_SIGNAL;
}

void CSubScanBinder::getTarget(IRA::CString& name,double &ra,double& dec,double& ra1,
  double& dec1,double &ra2,double& dec2) const
{
	name=m_name;
	ra=m_ra2000;
	dec=m_dec2000;
	ra1=m_ra1;
	dec1=m_dec1;
	ra2=m_ra2;
	dec2=m_dec2;
}

void CSubScanBinder::init()
{
		m_primary->targetName=CORBA::string_dup("");
		m_primary->type=Antenna::ANT_NONE;
		m_primary->paramNumber=0;
		m_primary->latitudeOffset=m_primary->longitudeOffset=0.0;
		m_primary->section=Antenna::ACU_NEUTRAL;
		m_primary->secondary=false;
		m_primary->enableCorrection=true;
		m_primary->applyOffsets=false;
		//m_primary->frame;
		//m_primary->equinox;
		//m_primary->offsetFrame;
		m_primary->VradFrame=Antenna::ANT_UNDEF_FRAME;
		m_primary->VradDefinition=Antenna::ANT_UNDEF_DEF;
		m_primary->RadialVelocity=0.0;
		m_secondary->targetName=CORBA::string_dup("");;
		m_secondary->type=Antenna::ANT_NONE;
		m_secondary->paramNumber=0;
		m_secondary->latitudeOffset=m_secondary->longitudeOffset=0.0;
		m_secondary->section=Antenna::ACU_NEUTRAL;
		m_secondary->secondary=false;
		m_secondary->enableCorrection=true;
		m_secondary->applyOffsets=false;
		//m_secondary->frame;
		//m_secondary->equinox;
		//m_secondary->offsetFrame;
		m_secondary->VradFrame=Antenna::ANT_UNDEF_FRAME;
		m_secondary->VradDefinition=Antenna::ANT_UNDEF_DEF;
		m_secondary->RadialVelocity=0.0;
		m_servo->range=0;
		m_servo->total_time=0;
		m_servo->axis_code=CORBA::string_dup("");;
		m_servo->is_empty_scan=true;
		m_receivers->dummy=0;
		m_subScanConf->signal=Management::MNG_SIGNAL_NONE;
		m_ra2000=m_dec2000=0.0;
		m_ra1=m_dec1=m_ra2=m_dec2=0.0;
		m_name="";
}

// **** PRVATE *********

void CSubScanBinder::copyPrimaryAntenaTrack(const Antenna::TTrackingParameters * const prim)
{
	if (prim!=NULL) {
		m_primary->targetName=CORBA::string_dup(prim->targetName);
		m_primary->type=prim->type;
		for (long k=0;k<Antenna::ANTENNA_TRACKING_PARAMETER_NUMBER;k++) m_primary->parameters[k]=prim->parameters[k];
		m_primary->paramNumber=prim->paramNumber;
		m_primary->frame=prim->frame;
		m_primary->equinox=prim->equinox;
		m_primary->longitudeOffset=prim->longitudeOffset;
		m_primary->latitudeOffset=prim->latitudeOffset;
		m_primary->offsetFrame=prim->offsetFrame;
		m_primary->applyOffsets=prim->applyOffsets;
		m_primary->secondary=false;
		m_primary->section=prim->section;
		m_primary->otf.lon1=prim->otf.lon1;
		m_primary->otf.lat1=prim->otf.lat1;
		m_primary->otf.lon2=prim->otf.lon2;
		m_primary->otf.lat2=prim->otf.lat2;
		m_primary->otf.coordFrame=prim->otf.coordFrame;
		m_primary->otf.geometry=prim->otf.geometry;
		m_primary->otf.subScanFrame=prim->otf.subScanFrame;
		m_primary->otf.description=prim->otf.description;
		m_primary->otf.direction=prim->otf.direction;
		m_primary->otf.subScanDuration=prim->otf.subScanDuration;
		m_primary->VradFrame=prim->VradFrame;
		m_primary->VradDefinition=prim->VradDefinition;
		m_primary->RadialVelocity=prim->RadialVelocity;
	}
}

void CSubScanBinder::addSecondaryAntennaTrack(const Antenna::TTrackingParameters * const sec)
{
	m_primary->secondary=true;
	if (sec!=NULL) {
		m_primary->targetName=CORBA::string_dup(sec->targetName);
		m_secondary->targetName=CORBA::string_dup(sec->targetName);
		m_secondary->type=sec->type;
		for (long k=0;k<Antenna::ANTENNA_TRACKING_PARAMETER_NUMBER;k++) m_secondary->parameters[k]=sec->parameters[k];
		m_secondary->paramNumber=sec->paramNumber;
		m_secondary->frame=sec->frame;
		m_secondary->equinox=sec->equinox;
		// offset will be ignore for secondary tracking set
		m_secondary->longitudeOffset=0.0;
		m_secondary->latitudeOffset=0.0;
		m_secondary->offsetFrame=sec->offsetFrame;
		m_secondary->applyOffsets=false;
		// **********************************************
		m_secondary->section=sec->section;
		m_secondary->secondary=false;
		m_secondary->otf.lon1=sec->otf.lon1;
		m_secondary->otf.lat1=sec->otf.lat1;
		m_secondary->otf.lon2=sec->otf.lon2;
		m_secondary->otf.lat2=sec->otf.lat2;
		m_secondary->otf.coordFrame=sec->otf.coordFrame;
		m_secondary->otf.geometry=sec->otf.geometry;
		m_secondary->otf.subScanFrame=sec->otf.subScanFrame;
		m_secondary->otf.description=sec->otf.description;
		m_secondary->otf.direction=sec->otf.direction;
		m_secondary->otf.subScanDuration=sec->otf.subScanDuration;
		m_secondary->VradFrame=sec->VradFrame;
		m_secondary->VradDefinition=sec->VradDefinition;
		m_secondary->RadialVelocity=sec->RadialVelocity;
	}
	else {
		m_secondary->secondary=false; m_secondary->paramNumber=0; m_secondary->applyOffsets=false;
		m_secondary->type=Antenna::ANT_NONE; m_secondary->enableCorrection=true;
	}
}

void CSubScanBinder::findTarget(const Antenna::TTrackingParameters * const track)
{  
	Antenna::TCoordinateFrame frame;
	Antenna::TSystemEquinox equinox;
	Antenna::TGeneratorType type;
	double lon,lat;
	if (track!=NULL) {
		m_name=track->targetName;
		type=track->type;
		if (track->type==Antenna::ANT_SIDEREAL) {
			if (track->paramNumber>=2) {
				lon=track->parameters[0];
				lat=track->parameters[1];
				frame=track->frame;
				equinox=track->equinox;
				//printf ("sidereal %s,%lf,%lf\n",(const char *)m_name,lon,lat);
			}
			else { // this deals with "track=sourcename"
				lon=0.0;
				lat=0.0;
				frame=Antenna::ANT_EQUATORIAL;
				equinox=Antenna::ANT_J2000;				
			}
		}
		else if (track->type==Antenna::ANT_OTF) {
			frame=track->otf.coordFrame;
			equinox=Antenna::ANT_J2000;
			if (track->otf.description==Antenna::SUBSCAN_CENTER) {
				lon=track->otf.lon1;
				lat=track->otf.lat1;			
			}
			else {
				if (track->otf.subScanFrame==frame) {
					lon=(track->otf.lon1+track->otf.lon2)/2.0;
					lat=(track->otf.lat1+track->otf.lat2)/2.0;				
				}
				else {
					m_name=UNDEFINEDTARGET;
					lon=lat=0.0;
				}
			}
		}
		else if (track->type==Antenna::ANT_MOON) {
			frame=Antenna::ANT_EQUATORIAL;
			equinox=Antenna::ANT_J2000;
			lon=lat=0.0;
		}
		else {  // All other cases, to be specified when new generators come alive
			lon=lat=0.0;
			m_name=UNDEFINEDTARGET;
			frame=Antenna::ANT_EQUATORIAL;
			equinox=Antenna::ANT_J2000;
		}
		if (frame==Antenna::ANT_EQUATORIAL) {
			if (equinox==Antenna::ANT_B1950) {
				IRA::CSkySource::B1950ToJ2000(lon,lat,m_ra2000,m_dec2000);
			} 
			else if (equinox==Antenna::ANT_APPARENT) {
				IRA::CDateTime tm; // convert to J200 epoch
				IRA::CSkySource::apparentToJ2000(lon,lat,tm,m_ra2000,m_dec2000);
			}
			else if (equinox==Antenna::ANT_J2000) {
				m_ra2000=lon;
				m_dec2000=lat;				
			}
		}
		else if (frame==Antenna::ANT_GALACTIC) {
			IRA::CSkySource::galacticToEquatorial(lon,lat,m_ra2000,m_dec2000);
		}
		else { //HORIZONTAL
			IRA::CDateTime tm; // convert to J200 epoch
			IRA::CSite st;
			st.cartesianCoordinates(0.4,0.4,100); // convert from a generic topocentric site
			double pA;
			IRA::CSkySource::horizontalToEquatorial(tm,st,lon,lat,m_ra2000,m_dec2000,pA);
		}			
	}
}

