trkfit.cc 44.3 KB
Newer Older
1 2 3 4 5 6
/*  PAON4 analysis software 
    classes and functions to read in and perform array geometry determination 
    using satellites and celestial sources tracks  
    R. Ansari, Fevrier 2019                                             */


7 8
#include <iomanip>

9 10 11
#include "pexceptions.h"
#include "trkfit.h"
#include "datacards.h"
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
#include "array.h"

#include "acbeam.h"
#include "gacfit.h"
#include "gcxfit.h"
#include "gcxfitbaseline.h"

#include "p4autils.h"


//------------------- Print Level for this file --------------------------
static int _prtlevel_ =0;
void TrkFit_SetPrintLevel(int lev) 
{ 
  _prtlevel_=lev; 
  return;
}
29

30 31 32 33 34 35 36 37 38 39 40 41
void TrkFit_FitLibInfo() 
{
  cout << "============================================================================"<<endl;
#ifndef TKF_AVEC_MINUIT
  cout << "============ Classe TkF_Fitter : Fitting with Sophya GeneralFit ============"<<endl;
#else 
  cout << "============= Classe TkF_Fitter : Fitting with Minuit MnMigrad ============="<<endl;
#endif
  cout << "============================================================================"<<endl;
  return;
}

42 43
//------------------- TrkInputDataSet -------------------------------------

44 45

TrkInputDataSet::TrkInputDataSet(string dcfilename, string inp_path)
46 47
  : zenang(0.) , theta_0(0.) , phi_0(0.)
{
48
  setInputBasePath(inp_path);
49 50 51 52 53 54 55 56 57
  ReadDatacardFile(dcfilename);
}


static vector<string> * dataflnm_p_ = NULL;
static vector<double> * tstart_p_ = NULL;
static vector<double> * tend_p_ = NULL;
static vector<double> * v_freqs_p_ = NULL;
static vector<string> * trkflnm_p_ = NULL;
58 59
static vector<bool> * v_noAC_p_ = NULL;
static vector<bool> * v_noCx_p_ = NULL;
60 61 62 63 64 65 66 67 68 69 70 71 72
static size_t trk_cnt = 0;

static int decode_trkcard(string const& key, string const& toks)
{
  if (key != "trk") {  // CA NE DEVRAIT PAS ARRIVER 
    cout << "decode_trkcard/ERROR  BAD key = " << key << " ( <> trk"<<endl;
    return 1;
  }
  if (! dataflnm_p_ ) { // CA NE DEVRAIT PAS ARRIVER
    cout << "decode_trkcard/ERROR  dataflnm_p_ = NULL !"<<endl;
    return 1;
  }
  char flnmdata[256], flnmtrk[256];
73
  char sflags[64];
74
  double ts,te,freq;
75
  sscanf(toks.c_str(),"%s %lg,%lg %lg %s %s",flnmdata,&ts,&te,&freq,flnmtrk,sflags);
76 77 78 79 80 81

  dataflnm_p_->push_back(flnmdata);
  tstart_p_->push_back(ts*60.);
  tend_p_->push_back(te*60.);
  v_freqs_p_->push_back(freq);
  trkflnm_p_->push_back(flnmtrk);
82 83 84 85 86 87 88 89 90 91 92
  size_t ll=strlen(sflags);
  bool noAC=false;
  bool noCx=false;
  if (ll>0) {
    for(size_t l=0; l<ll; l++)  sflags[l]=toupper(sflags[l]);
    string sflg=sflags;
    if ((sflg == "NOAC")||(sflg=="NOACCX"))  noAC=true;
    if ((sflg == "NOCX")||(sflg=="NOACCX"))  noCx=true;
  }
  v_noAC_p_->push_back(noAC);
  v_noCx_p_->push_back(noCx);
93 94 95 96 97
  trk_cnt++;
  return 0;
}


98 99 100 101 102 103
void TrkInputDataSet::setInputBasePath(string inp_path)
{
  if (inp_path.length()>0)  input_base_path=inp_path;
  return;
}

104 105 106
size_t TrkInputDataSet::ReadDatacardFile(string dcfilename)
{
  DataCards dc;
107
  string match="trk";
108 109 110 111 112 113 114 115 116 117 118 119 120
  dc.AddProcF(decode_trkcard, match);

  zenang=0.; theta_0=0.;  phi_0=0.;
  dataflnm.clear();
  tstart.clear();
  tend.clear();
  v_freqs.clear();
  trkflnm.clear();
  dataflnm_p_ = &dataflnm;
  tstart_p_ = &tstart;
  tend_p_ = &tend;
  v_freqs_p_ = &v_freqs;
  trkflnm_p_ = &trkflnm;
121 122
  v_noAC_p_=&v_noAC;
  v_noCx_p_=&v_noCx;
123
  trk_cnt = 0;
124
  // @trk visiDataTableFile tstart,tend freq TrackFileName [FLAG]
125
  //  tstart , tend in minutes freq in MHz
126 127 128
  //  optional FLAG   = NOAC  NOCX   NOACCX   
  //  NOAC : don't use for Auto-correlation fit ;  NOCX : don't use for cross-cor fits 
  //  NOACCX : don't use for Auto-correlation or cross-cor fits 
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
  dc.ReadFile(dcfilename);
  if (dc.HasKey("inpath"))   {   // @inpath  InputFilesDirectoryPath    
    input_base_path = dc.SParam("inpath",0,"");
  }
  if (dc.HasKey("zenang"))   {   // @zenang  Zenith Angle in degree   
    zenang = dc.DParam("zenang",0,0.);
    if (zenang<0.) {
      theta_0 = Angle(-zenang, Angle::Degree).ToRadian();  phi_0 = Angle::PioTwoCst()+Angle::OnePiCst();
    }
    else {
      theta_0 = Angle(+zenang, Angle::Degree).ToRadian();  phi_0 = Angle::PioTwoCst();
    }
  }

  dataflnm_p_ = NULL;
  tstart_p_ = NULL;
  tend_p_ = NULL;
  v_freqs_p_ = NULL;
  trkflnm_p_ = NULL;

  if (trk_cnt != trkflnm.size()) {  // ca ne devrait pas arriver
    cout << " TrkInputDataSet::ReadDatacardFile()/BUG  trk_cnt != trkflnm.size()"<<endl;
    throw PError("TrkInputDataSet::ReadDatacardFile() trk_cnt != trkflnm.size()");
  }
  trk_cnt=0;
  dcfilename_ = dcfilename;
  return trkflnm.size();
}

ostream & TrkInputDataSet::Print(ostream & os) const
{
  os << "TrkInputDataSet(dcfilename="<<dcfilename_<<")/Info:  dec-shift(zenithAngle)= "<<zenang<<" NbTrk="<<NbTrk()<<endl;
  os << "...InputBaseDirectoryPath="<<input_base_path<<endl;
  for(size_t i=0; i<NbTrk(); i++)  {
    os <<"["<<i<<"] data= "<< dataflnm[i]<<"  ts,te(min)= "<<tstart[i]/60.<<","<<tend[i]/60.<<" freg(MHz)= "<<v_freqs[i]
       <<" TrkFile="<<trkflnm[i]<<endl;
  }
  return os;
}


170 171 172 173 174 175 176 177 178 179 180 181

//------------------------ ACxDataSet -------------------------------------

AcxDataSet::AcxDataSet(TrkInputDataSet & tkds)
  : tot_npoints(0),zenang(0.),theta_0(0.),phi_0(0.)
{
  ReadData(tkds);
}

AcxDataSet::AcxDataSet(AcxDataSet const & a)
  : v_time_data(a.v_time_data), vv_data(a.vv_data), vv_err(a.vv_err), 
    v_min_data(a.v_min_data), v_max_data(a.v_max_data),
182 183
    vv_cxdata(a.vv_cxdata), vv_cxerr(a.vv_cxerr),
    v_min_cxdata(a.v_min_cxdata), v_max_cxdata(a.v_max_cxdata), 
184
    tot_npoints(a.tot_npoints), v_freqs(a.v_freqs), v_noAC(a.v_noAC), v_noCx(a.v_noCx), 
185 186
    zenang(a.zenang), theta_0(a.theta_0), phi_0(a.phi_0),
    v_acbeams(a.v_acbeams), v_cxbeams(a.v_cxbeams),
187
    v_phase(a.v_phase), v_phi_0(a.v_phi_0), v_a_phi(a.v_a_phi), v_Acx(a.v_Acx), v_Bcx(a.v_Bcx)
188 189 190 191 192 193 194
{
}

AcxDataSet & AcxDataSet::operator = (AcxDataSet const & a)
{
  v_time_data=a.v_time_data; vv_data=a.vv_data; vv_err=a.vv_err; 
  v_min_data=a.v_min_data;   v_max_data=a.v_max_data;
195 196
  vv_cxdata=a.vv_cxdata;   vv_cxerr=a.vv_cxerr;
  v_min_cxdata=a.v_min_cxdata;  v_max_cxdata=a.v_max_cxdata; 
197
  tot_npoints=a.tot_npoints; v_freqs=a.v_freqs;   v_noAC=a.v_noAC;  v_noCx=a.v_noCx;
198 199
  zenang=a.zenang;  theta_0=a.theta_0;  phi_0=a.phi_0;
  v_acbeams=a.v_acbeams;  v_cxbeams=a.v_cxbeams;
200
  v_phase=a.v_phase; v_phi_0=a.v_phi_0;  v_a_phi=a.v_a_phi;  v_Acx=a.v_Acx;  v_Bcx=a.v_Bcx;
201

202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
  return (*this);
}

size_t AcxDataSet::ReadData(TrkInputDataSet & tkds)    
{
  cout << "---- AcxDataSet::AcxDataSet() reading 4 PAON4 auto-correlation & 6 Cross-cor signals/DataTables for"
       <<tkds.NbTrk()<<" tracks ..."<<endl;

  if (tkds.NbTrk() != v_time_data.size()) {
    v_time_data.resize(tkds.NbTrk());
    vv_data.resize(tkds.NbTrk());
    vv_err.resize(tkds.NbTrk());
    v_min_data.resize(tkds.NbTrk());
    v_max_data.resize(tkds.NbTrk());
    vv_cxdata.resize(tkds.NbTrk());
    vv_cxerr.resize(tkds.NbTrk());
    v_min_cxdata.resize(tkds.NbTrk());
    v_max_cxdata.resize(tkds.NbTrk());    
  }
221
  v_freqs=tkds.v_freqs;  v_noAC=tkds.v_noAC;  v_noCx=tkds.v_noCx;
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
  zenang=tkds.zenang;   theta_0=tkds.theta_0;    phi_0=tkds.phi_0;
  size_t NB_ANTENNES=getNbAutoCor();   // nombre d'antennes 
  size_t NB_CXCORS=getNbCrossCor();
  tot_npoints = 0;   // total number of points for fit 
  const char * acname[4]={"V11","V22","V33","V44"};
  const char * cxname[6]={"V12","V13","V14","V23","V24","V34"};
  
  for(size_t j=0; j<tkds.dataflnm.size(); j++) {
    string flnm = tkds.input_base_path+tkds.dataflnm[j]+".ppf";
    cout << "1."<<j+1<<" Extracting data from data file DataTable: " << flnm<<endl
	 << " ... For time interval (Trk"<<j+1<<") "<<tkds.tstart[j]<<" < t < "<<tkds.tend[j]<<endl;
    DataTable dt_data;
    PInPersist pin(flnm);
    pin >> dt_data;
    dt_data.SetShowMinMaxFlag(true);
    size_t ktime = dt_data.IndexNom("timesec");
    vector<double> vtm;
    dt_data.GetColumn(ktime, vtm);
    vector< vector<double> > v_vac(NB_ANTENNES);
    for(size_t ii=0; ii<NB_ANTENNES; ii++) {   // 4 auto-correlations
      size_t kac = dt_data.IndexNom(acname[ii]);
      dt_data.GetColumn(kac, v_vac[ii]);
      vector<double> vtmp, vetmp;
      vv_data[j].push_back(vtmp);
      vv_err[j].push_back(vetmp);
      v_min_data[j].push_back(9.e19);
      v_max_data[j].push_back(-9.e19);
    }
    vector< vector <complex<double> > > v_vcx(NB_CXCORS);
    for(size_t ii=0; ii<NB_CXCORS; ii++) {   // 6 cross-correlations
      size_t kac = dt_data.IndexNom(cxname[ii]);
      dt_data.GetColumn(kac, v_vcx[ii]);
      vector< complex<double> > vtmp;
      vector<double> vetmp;
      vv_cxdata[j].push_back(vtmp);
      vv_cxerr[j].push_back(vetmp);
      v_min_cxdata[j].push_back(9.e19);
      v_max_cxdata[j].push_back(-9.e19);
    }
    
    vector< vector<double> > & v_data = vv_data[j];
    vector< vector<double> > & v_err = vv_err[j];
    vector< vector< complex<double> > > & v_cxdata = vv_cxdata[j];
    vector< vector<double> > & v_cxerr = vv_cxerr[j];

    for(size_t k=0; k<vtm.size(); k++) {
      if ((vtm[k]<tkds.tstart[j])||(vtm[k]>tkds.tend[j]))  continue;
      v_time_data[j].push_back(vtm[k]);
      for(size_t ii=0; ii<NB_ANTENNES; ii++) {
	vector<double> & vac = v_vac[ii];
	v_data[ii].push_back(vac[k]);
	v_err[ii].push_back(0.1*sqrt(fabs(vac[k])));   // calcul d'erreur, a affiner 
	if (vac[k]<v_min_data[j][ii])  v_min_data[j][ii]=vac[k];
	if (vac[k]>v_max_data[j][ii])  v_max_data[j][ii]=vac[k];
      }
      for(size_t ii=0; ii<NB_CXCORS; ii++) {   // 6 cross-correlations
	vector< complex<double> > & vcx = v_vcx[ii];
	v_cxdata[ii].push_back(vcx[k]);
	double acx=std::abs(vcx[k]);
	v_cxerr[ii].push_back(0.1*sqrt(acx));
	if (acx<v_min_cxdata[j][ii])  v_min_cxdata[j][ii]=acx;
	if (acx>v_max_cxdata[j][ii])  v_max_cxdata[j][ii]=acx;
      }
    }
    
    tot_npoints += v_time_data[j].size();   // total number of points for fit 
    cout << " ... Done for " << j+1 << " data size="<<v_time_data[j].size()<<endl;
    cout << "  Data-AutoCor Min,Max[A1...A4]="; 
    for(size_t ii=0; ii<NB_ANTENNES; ii++)
      cout<<setw(10)<<v_min_data[j][ii]<<","<<setw(10)<<v_max_data[j][ii]<<" ; ";   cout << endl;
    cout << "  Data-CxCorr (abs) Min,Max[Cx1...Cx6]="; 
    for(size_t ii=0; ii<NB_ANTENNES; ii++)
      cout<<setw(10)<<v_min_cxdata[j][ii]<<","<<setw(10)<<v_max_cxdata[j][ii]<<" ; ";   cout << endl;

  }
  return tot_npoints;
}


//------------------------ TrackSet -------------------------------------
TrackSet::TrackSet(TrackSet const & a)
  : v_time_sat(a.v_time_sat), v_sat_elev(a.v_sat_elev), v_sat_azim(a.v_sat_azim),
    v_interp_elev(a.v_interp_elev), v_interp_sazim(a.v_interp_sazim)							   
{
}

TrackSet & TrackSet::operator = (TrackSet const & a)
{
  v_time_sat=a.v_time_sat;  v_sat_elev=a.v_sat_elev;  v_sat_azim=a.v_sat_azim;
  v_interp_elev=a.v_interp_elev;  v_interp_sazim=a.v_interp_sazim; 
  return *this;
}

TrackSet::TrackSet(TrkInputDataSet & tkds)
{
  ReadData(tkds);
}

320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
size_t TrackSet::ReadTrackFile(string flnm, vector<double> & tims, vector<double> & elevs, vector<double> & azims, SLinInterp1D & li_elev, SLinInterp1D & li_sazim)
{
  cout <<"TrackSet::ReadTrackFile() Extracting data from source/satellite track DataTables: Filename= " << flnm << endl;
  DataTable dt_sat;
  PInPersist pin(flnm);
  pin >> dt_sat;
  dt_sat.SetShowMinMaxFlag(true);
  size_t ktime = dt_sat.IndexNom("timesec");
  dt_sat.GetColumn(ktime, tims);
  size_t kelev = dt_sat.IndexNom("elevation");
  dt_sat.GetColumn(kelev, elevs);
  size_t kazim = dt_sat.IndexNom("azimuth");
  dt_sat.GetColumn(kazim, azims);
  li_elev.DefinePoints(tims, elevs);
  double last_azim=azims[0];
  //    vector<double> cazim(v_sat_azim[j].size());
  // azimuth values, shifted possibly +360 +720 deg ... to avoid jumping from 360 deg to 0 deg  
  vector<double> shifted_azim(azims.size());   
  double azim_offset=0.;
  double min_azim_offset=0.;
  bool fgneg_azim_offset=false;
  for(size_t k=0; k<azims.size(); k++)  {
    double azim=azims[k];
    if ((k>0)&&(azim<last_azim)) {
      if ((last_azim>300.)&&(azim<60.))  {
	azim_offset += 360.;
	if (_prtlevel_>0) 
	  cout << "TrackSet::ReadTrackFile()/Info-Warning: 360 to 0 deg. Jump k="<<k<<" last_azim="<<last_azim<<" azimuth= "<<azim<<" Offset->"<<azim_offset<<endl;
      }
    }
    else if ((k>0)&&(azim>last_azim)) {
      if ((last_azim<60)&&(azim>300.))  {
	azim_offset -= 360.;
	if (_prtlevel_>0) 
	  cout << "TrackSet::ReadTrackFile()/Info-Warning: 0 to 360 deg. Jump: k="<<k<<" last_azim="<<last_azim<<" azimuth= "<<azim<<" Offset->"<<azim_offset<<endl;
      }
    }
    if (azim_offset<min_azim_offset)  min_azim_offset=azim_offset;
    last_azim = azim;
    shifted_azim[k]=azim+azim_offset;
    /*
      double phisrcdeg=90.-v_sat_azim[j][k];
      if (phisrcdeg<0.)  phisrcdeg+=360.;
      double phisrc=Angle(phisrcdeg,Angle::Degree).ToRadian();
      cazim[k]=cos(phisrc);
    */
  }
  if (min_azim_offset < -300.) {
    cout << "TrackSet::ReadTrackFile()/Info-Warning: - correcting for negative azim_offset -> Adding " << -min_azim_offset <<" deg."<<endl;
    for(size_t k=0; k<shifted_azim.size(); k++)   shifted_azim[k] -= min_azim_offset;
  }
  li_sazim.DefinePoints(tims, shifted_azim);
  return tims.size();
}

375 376 377 378 379 380 381 382 383 384 385 386 387 388
size_t TrackSet::ReadData(TrkInputDataSet & tkds)
{
  cout << "---- TrackSet::ReadData() ; reading source (satellites, ..) for "
       <<tkds.NbTrk()<<" tracks ..."<<endl;
  if (tkds.NbTrk() != v_time_sat.size()) {
    v_time_sat.resize(tkds.NbTrk());
    v_sat_elev.resize(tkds.NbTrk());
    v_sat_azim.resize(tkds.NbTrk());
    v_interp_elev.resize(tkds.NbTrk());
    v_interp_sazim.resize(tkds.NbTrk());
  }

  for(size_t j=0; j<tkds.NbTrk(); j++) {
    string flnm = tkds.input_base_path+tkds.trkflnm[j]+".ppf";
389 390 391 392 393
    size_t npts=ReadTrackFile(flnm, v_time_sat[j], v_sat_elev[j], v_sat_azim[j], v_interp_elev[j], v_interp_sazim[j]);
    cout<<"["<<j+1<<"]  DONE timevec.size()="<<npts<<"  SLinInterp1D for elevation / azimuth created ..."<<endl;
    if (_prtlevel_>0) {
      cout << v_interp_elev[j];
      cout << v_interp_sazim[j];
394
    }
395 396 397 398 399
  }
  return 0;
}


400
//------------------------ ACxSetFitter -------------------------------------
401
ACxSetFitter::ACxSetFitter(AcxDataSet & data, TrackSet & tks)
402
  : fggaussbeam_(true), D_dish(5.), acxd_(data), tks_(tks), fit_ac_done(false), fit_cx_done(false), 
403 404 405 406 407
    v_RcFit_ac(tks.getNbAutoCor()), v_xi2red_ac(tks.getNbAutoCor()),
    v_Ddish(tks.getNbAutoCor()), v_thetaant(tks.getNbAutoCor()), 
    v_phiant(tks.getNbAutoCor()), v_A(tks.getNbAutoCor()), v_B(tks.getNbAutoCor()), 
    v_err_Ddish(tks.getNbAutoCor()), v_err_thetaant(tks.getNbAutoCor()), 
    v_err_phiant(tks.getNbAutoCor()), v_err_A(tks.getNbAutoCor()), v_err_B(tks.getNbAutoCor()), 
408
    v_acbeams(tks.getNbAutoCor()),
409
    v_RcFit_cx(tks.getNbCrossCor()), v_xi2red_cx(tks.getNbCrossCor()),
410 411 412 413
    v_phase(tks.getNbCrossCor()), v_phi_0(tks.getNbCrossCor()), v_a_phi(tks.getNbCrossCor()), 
    v_Acx(tks.getNbCrossCor()), v_Bcx(tks.getNbCrossCor()), 
    v_err_phi_0(tks.getNbCrossCor()), v_err_a_phi(tks.getNbCrossCor()), 
    v_err_Acx(tks.getNbCrossCor()), v_err_Bcx(tks.getNbCrossCor()),
414
    v_cxbeams(tks.getNbCrossCor())
415
{
416 417 418 419
  if (data.NbTrk() != tks.NbTrk())
    throw ParmError("ACxSetFitter(data, tks) NOT same number of tracks NbTrk() in data and tks");
  if (data.NbTrk() < 1)
    throw ParmError("ACxSetFitter(data, tks) 0 tracks in data data.NbTrk()<1 ");
420 421 422 423 424 425 426 427
}

int ACxSetFitter::doACfit(string outfilename)
{
  cout << "======================================================================================"<<endl;
  cout << "---- ACxSetFitter::doACfit() ; Performing antenna pointing fit ..."<<endl;
  ofstream ofr(outfilename.c_str());
  ofr << "#### Pointing/dish diameter fit on autocorrelation (ACxSetFitter::doACfit() "<<endl
428
      << "## NumAntenna RcFit Xi2red  Deff err_Deff  Elevation err_Elev  Azimuth err_Ezim  A0 err_A0 B0 err_B0 A1 err_A1 B1 err_B1 ..."<<endl;
429 430 431 432 433 434 435 436
  size_t NB_ANTENNES = acxd_.getNbAutoCor();
  size_t NTRK = acxd_.NbTrk();

  for(size_t ii=0; ii<NB_ANTENNES; ii++)  { 
    v_A[ii].resize(NTRK);     v_B[ii].resize(NTRK); 
    v_err_A[ii].resize(NTRK);     v_err_B[ii].resize(NTRK); 
  }
  int tot_npoints_fit = 0;
437 438 439 440
  for(size_t j=0; j<NTRK; j++) {
    if (acxd_.v_noAC[j])  continue;
    tot_npoints_fit += acxd_.v_time_data[j].size();
  }
441 442 443 444
  for(size_t ii=0; ii<NB_ANTENNES; ii++) {
    cout << "-------- doACfit() 1."<<ii+1<<" Creating General Fit for AutoCor Antenna= " << ii+1 << endl;
    GeneralFitData gdata(1, tot_npoints_fit);
    for(size_t j=0; j<NTRK; j++) {
445
      if (acxd_.v_noAC[j])  continue;
446 447 448 449 450 451
      vector< vector<double> > & v_data = acxd_.vv_data[j];
      vector< vector<double> > & v_err = acxd_.vv_err[j];
      for(size_t k=0; k<acxd_.v_time_data[j].size(); k++) {
	gdata.AddData1(acxd_.v_time_data[j][k],v_data[ii][k],v_err[ii][k]); // Fill x, y and error on y     
      }
    }
452 453 454 455
    TkF_ACXi2 gxi2( acxd_.v_time_data, acxd_.vv_data, acxd_.vv_err, acxd_.v_freqs, acxd_.v_noAC, 
		    tks_.v_interp_elev, tks_.v_interp_sazim, ii, fggaussbeam_);  // MyACGenXi2
    //    GeneralFit mFit(&gxi2);
    TkF_Fitter mFit(gxi2);
456
    mFit.SetData(&gdata);        // connect data to the fitter , here the data is unused - gxi2 includes its data 
457
    mFit.SetMaxStep(5000);
458
    // SetParam(int n,double value, double step,double min=1., double max=-1.);
459
    mFit.SetParam(0,"D_dish",D_dish,0.1,D_dish*0.7,D_dish*1.4);
460 461 462 463 464 465 466 467 468 469 470 471 472
    // mFit.SetFix(0, D_dish);
    
    double thetaAntenne=0., phiAntenne=0.;
    if (fabs(acxd_.zenang)>1.e-6) {
      if (acxd_.zenang<0)  {
	thetaAntenne=Angle(-acxd_.zenang,Angle::Degree).ToRadian();
	phiAntenne=Angle(270.,Angle::Degree).ToRadian();
      }
      else {
	thetaAntenne=Angle(acxd_.zenang,Angle::Degree).ToRadian();
	phiAntenne=Angle(90.,Angle::Degree).ToRadian();
      }
    }
473
    mFit.SetParam(1,"ThetaAntenne",thetaAntenne,M_PI/1440,0.,M_PI/4.); // thetaAntenne+M_PI/30.); // 
474 475 476
    mFit.SetParam(2,"PhiAntenne",phiAntenne,M_PI/180.,0.,2.*M_PI);
    // mFit.SetFix(1, thetaAntenne);
    // mFit.SetFix(2, phiAntenne);
477

478
    //DEL    size_t jj=0;
479
    for(size_t j=0; j<NTRK; j++) {
480 481 482 483
      double A = acxd_.v_max_data[j][ii];
      double B = acxd_.v_min_data[j][ii];
      v_A[ii][j]=A;   v_err_A[ii][j]=0.;
      v_B[ii][j]=B;   v_err_B[ii][j]=0.;
484
      //DEL if (acxd_.v_noAC[j])  continue;
485 486
      char pname[32];
      sprintf(pname,"A%d",(int)(j+1));
487
      mFit.SetParam(2*j+3,pname,A,A/10.,A/20,A*5);
488
      sprintf(pname,"B%d",(int)(j+1));
489 490 491 492 493 494 495
      mFit.SetParam(2*j+4,pname,B,B/10.,B/20,B*5);
      // mFit.SetFix(2*jj+4, B);
      if (acxd_.v_noAC[j]) {
	mFit.SetFix(2*j+3, A);
	mFit.SetFix(2*j+4, B);
      }
      //DEL      jj++;
496 497 498
    }
    //DBG mFit.PrintFit();
    //    cout << "do_p4_trkfit 2."<<ii+1<<" Performing the fit for AutoCor Antenna= " << ii+1 << endl;
499
    int rcfit = mFit.doFit();
500 501 502 503 504 505 506 507 508 509 510
    if (_prtlevel_>1) mFit.PrintFit();
    v_RcFit_ac[ii]=rcfit;  v_xi2red_ac[ii]=-9999.;
    if(rcfit>0) { 
      cout<< "------- Fit result for Antenna No="<<ii+1<<" Reduce_Chisquare = " << mFit.GetChi2Red()
	  << " nstep="<<mFit.GetNStep() << " rc="<<rcfit<<endl;
    }
    else {
      cout << "---Fit failed for "<<ii+1<<"--- Fit_Error, rc = " << rcfit << "  nstep="<<mFit.GetNStep()<<endl;
      ofr <<setw(4)<<ii+1<<" ERROR FIT RC="<<rcfit<<"  nstep="<<mFit.GetNStep()<<endl;
      if (_prtlevel_>0) mFit.PrintFitErr(rcfit);
    } 
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534

    ofr <<setw(4)<<ii+1<<" "<<setw(8)<<mFit.GetChi2Red()<<" "; 
    v_xi2red_ac[ii]=mFit.GetChi2Red();
    double Dfit=mFit.GetParm(0);   double err_Dfit=mFit.GetParmErr(0);
    cout <<setw(16)<<"DishDiameter= "<<setw(10)<<Dfit<<" +/- "<<setw(10)<<err_Dfit<<" m."<<endl;
    ofr <<setw(5)<<rcfit<<" "<<setw(8)<<Dfit<<" "<<setw(8)<<err_Dfit<<"  "; 
    v_Ddish[ii]=Dfit;
    v_err_Ddish[ii]=err_Dfit;
    double thetaant=mFit.GetParm(1);   double err_thetaant=mFit.GetParmErr(1);
    v_thetaant[ii]=thetaant;
    double elevdeg=90.-Angle(thetaant).ToDegree();
    double err_elevdeg=Angle(err_thetaant).ToDegree();
    cout <<setw(16)<<"ThetaAntenne= "<<setw(12)<<Angle(thetaant).ToDegree()<< " +/- "
	 <<setw(12)<<Angle(err_thetaant).ToDegree()<<" (elevation="
	 <<setw(8)<<elevdeg<<" +/- "<<setw(8)<<err_elevdeg<<") deg."<<endl;
    ofr <<setw(8)<<elevdeg<<" "<<setw(8)<<err_elevdeg<<"  "; 
    double phiant=mFit.GetParm(2);   double err_phiant=mFit.GetParmErr(2);
    double azimdeg=90.-Angle(phiant).ToDegree();
    if (azimdeg<0.)  azimdeg += 360.;
    double err_azimdeg=Angle(err_phiant).ToDegree();
    v_phiant[ii]=phiant;
    cout <<setw(16)<<"PhiAntenne= "<<setw(12)<<Angle(phiant).ToDegree()<< " +/- "
	 <<setw(12)<<Angle(err_phiant).ToDegree()<<" (azimuth  ="
	 <<setw(8)<<azimdeg<<" +/- "<<setw(8)<<err_azimdeg<<" ) deg."<<endl;
535
    ofr <<setw(8)<<azimdeg<<" "<<setw(8)<<err_azimdeg<<"  ";
536
    //DEL    jj=0;
537
    for(size_t j=0; j<NTRK; j++) {
538 539 540 541 542
      double A = acxd_.v_max_data[j][ii];
      double B = acxd_.v_min_data[j][ii];
      double err_A = 0.;
      double err_B = 0.;
      if (!acxd_.v_noAC[j])  {
543 544 545
	A=mFit.GetParm(3+2*j);    err_A=mFit.GetParmErr(3+2*j);
	B=mFit.GetParm(4+2*j);    err_B=mFit.GetParmErr(4+2*j);
	//	jj++;
546
      }
547
      v_A[ii][j]=A;  v_err_A[ii][j]=err_A;  v_B[ii][j]=B;  v_err_B[ii][j]=err_B;
548
      cout << "  Trk/Sat["<<j<<"] -> A= "<<A<<" +/- "<<err_A<<"  B= "<<B<<" +/- "<<err_B<<(acxd_.v_noAC[j]?" FIXED":"")<<endl;
549
      if (acxd_.v_noAC[j])
550
	ofr <<setw(8)<<A<<" "<<setw(8)<<" NOFIT "<<" "<<setw(8)<<B<<" "<<setw(8)<<" FIXED "<<" ";
551 552
      else 
	ofr <<setw(8)<<A<<" "<<setw(8)<<err_A<<" "<<setw(8)<<B<<" "<<setw(8)<<err_B<<" ";
553 554 555 556 557 558 559 560 561 562 563
    }
    ofr << endl;
    double clight = PhysQty::c().SIValue();
    double lambda = clight/(acxd_.v_freqs[0]*1.e6);
    ACBeam acb1(Dfit, thetaant, phiant, lambda);
    acb1.setGaussianLobe(fggaussbeam_);
    ACBeam acb2(Dfit, thetaant, phiant, lambda);
    acb2.setGaussianLobe(fggaussbeam_);
    Vector3d baseline0(0.,0.,0.);
    v_acbeams[ii]=CxBeam(acb1, acb2, baseline0);
    
564 565
  }
  
566 567
  fit_ac_done=true;
  acxd_.v_acbeams=v_acbeams;
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
  return 0;
}

int ACxSetFitter::saveExpectedAC(string outcheckfilename)
{
  if (outcheckfilename.length()<1)  return 1;
  cout << "-----ACxSetFitter::saveExpectedAC() : computing expected signal for fitted params , will be saved to file "
       <<outcheckfilename<<endl;
  POutPersist pos(outcheckfilename);
  size_t NB_ANTENNES = acxd_.getNbAutoCor();
  size_t NTRK = acxd_.NbTrk();

  for(size_t ii=0; ii<NB_ANTENNES; ii++)     {
    if (_prtlevel_>1) 
      cout << "... Computing DataSignal & Expected Signal for fitted params and dish "<<ii+1<<endl;
    
584
    MyACSignal macs(acxd_.v_time_data, acxd_.vv_data, acxd_.vv_err, acxd_.v_freqs, acxd_.v_noAC, 
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
		    tks_.v_interp_elev, tks_.v_interp_sazim, ii, fggaussbeam_);
      
    double Ddishfit=v_Ddish[ii];
    double thetafit=v_thetaant[ii];
    double phifit=v_phiant[ii];
    
    char oname[32];
    for(size_t j=0; j<NTRK; j++)  {
      double A = v_A[ii][j];
      double B = v_B[ii][j];
      Vector signal = macs.getDataSignal(j);
      sprintf(oname,"ac_%d_%d",(int)ii+1,(int)j+1);
      pos << PPFNameTag(oname)<<signal;
      Vector expsignal = macs.getExpectedSignal(j, Ddishfit, thetafit, phifit, A, B);
      sprintf(oname,"simac_%d_%d",(int)ii+1,(int)j+1);      
      pos << PPFNameTag(oname)<<expsignal;
601 602 603 604 605
      if (ii==0)  {
	Vector tmvec = macs.getTimeVec(j);
	sprintf(oname,"tim_%d",(int)j+1);
	pos << PPFNameTag(oname)<<tmvec;
      }
606 607 608 609 610 611
    }
  } 
  return 0;
}


612
int ACxSetFitter::doCxfit(string outfilenamecx, bool useAac, bool fgphi0only)
613 614 615 616 617 618
{
  size_t NB_ANTENNES=acxd_.getNbAutoCor();   // nombre d'antennes 
  size_t NB_CXCORS=acxd_.getNbCrossCor();
  size_t NTRK = acxd_.NbTrk();

  cout << "======================================================================================"<<endl;
619
  cout << "---------- ACxSetFitter::doCxfit() ; Performing cross-cor phase fit for NTrk="<<NTRK<<endl;
620 621 622
  if (useAac) cout << " ... Using Amplitude from auto-correlations fit for initial fit parameter value..."<<endl; 
  ofstream ofr(outfilenamecx.c_str());
  ofr << "#### cross-cor phase fit (ACxSetFitter::doCxfit() ) "<<endl
623
      << "## NumCxCor RcFit Xi2red Phi0 err_Phi0 a_Phi err_a_Phi (deg) A0 err_A0 A1 err_A1  ..."<<endl;
624 625
  int tot_npoints_fit = 0;
  for(size_t j=0; j<NTRK; j++) tot_npoints_fit += 2*(acxd_.v_time_data[j].size());
626 627
  cout << " Total number of data points for fit="<< tot_npoints_fit<<endl;

628 629 630 631
  size_t Anum1[6]={0,0,0,1,1,2};
  size_t Anum2[6]={1,2,3,2,3,3};
  for(size_t ii=0; ii<NB_CXCORS; ii++) {
    v_Acx[ii].resize(NTRK);   
632 633 634
    v_Bcx[ii].resize(NTRK);  
    v_err_Acx[ii].resize(NTRK);   
    v_err_Bcx[ii].resize(NTRK);  
635 636
    for(size_t j=0; j<NTRK; j++) {
      v_Acx[ii][j]=1.;   v_Bcx[ii][j]=complex<double>(0.,0.);
637
      v_err_Acx[ii][j]=1.;   v_err_Bcx[ii][j]=complex<double>(0.,0.);
638
    }
639 640 641 642 643 644 645 646 647 648 649
    Vector3d baseline=P4Coords::getBaseline(Anum1[ii]+1,Anum2[ii]+1);
    cout << "--------- 1."<<ii+1<<" doCxfit() Doing fit for CrossCor= " << ii << " FxF= " 
	 << Anum1[ii]+1<<"x"<<Anum2[ii]+1<<" Baseline="<<baseline<<endl;
    GeneralFitData gdata(1, tot_npoints_fit);
    for(size_t j=0; j<NTRK; j++) {
      vector< vector< complex<double> > > & v_cxdata = acxd_.vv_cxdata[j];
      vector< vector<double> > & v_cxerr = acxd_.vv_cxerr[j];
      for(size_t k=0; k<acxd_.v_time_data[j].size(); k++) {
	gdata.AddData1(acxd_.v_time_data[j][k],v_cxdata[ii][k].real(),v_cxerr[ii][k]); // Fill x, y and error on y
	gdata.AddData1(acxd_.v_time_data[j][k],v_cxdata[ii][k].imag(),v_cxerr[ii][k]); // Fill x, y and error on y     
      }
650
    }
651 652 653 654 655 656 657
    double clight = PhysQty::c().SIValue();
    double lambda = clight/(acxd_.v_freqs[0]*1.e6);
    ACBeam acb1(v_Ddish[Anum1[ii]], v_thetaant[Anum1[ii]], v_phiant[Anum1[ii]], lambda);
    acb1.setGaussianLobe(fggaussbeam_);
    ACBeam acb2(v_Ddish[Anum2[ii]], v_thetaant[Anum2[ii]], v_phiant[Anum2[ii]], lambda);
    acb2.setGaussianLobe(fggaussbeam_);
    CxBeam cxbeam(acb1, acb2, baseline);
658
    v_cxbeams[ii]=cxbeam;
659

660 661 662 663
    TkF_CxXi2 gxi2( acxd_.v_time_data, acxd_.vv_cxdata, acxd_.vv_cxerr, acxd_.v_freqs, 
		    tks_.v_interp_elev, tks_.v_interp_sazim, cxbeam, ii);  // MyCxGenXi2
    //    GeneralFit mFit(&gxi2);
    TkF_Fitter mFit(gxi2);
664
    mFit.SetData(&gdata);        // connect data to the fitter , here the data is unused - gxi2 includes its data 
665
    mFit.SetMaxStep(3000);
666
    // SetParam(int n,double value, double step,double min=1., double max=-1.);
667
    mFit.SetParam(0,"Phi_0",0.5*M_PI,M_PI/360.,0.,2.2*M_PI);
668 669 670 671 672 673
    mFit.SetParam(1,"a_phi",0.,0.05,-15.,15.);
    if (fgphi0only) {
      cout << " ACxSetFitter::doCxfit() Fitting Phi0 Only (frequency independent phase)"<<endl;
      mFit.SetFix(1,0.);
    }
    else cout << " ACxSetFitter::doCxfit() Fitting  Phase(freq) = Phi0 + a_Phi * (freq-1250.)/250. "<<endl;
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690

    char oname[32];
    vector<double> v_amp(NTRK);
    for(size_t j=0; j<NTRK; j++) {
      double A=1.; // v_max_cxdata[j][ii]; 
      TVector< complex<double> >  signal = gxi2.getDataSignal(j);
      Vector asig = SOPHYA::abs(signal);
      double mins, maxs;
      asig.MinMax(mins, maxs);
      TVector< complex<double> >  expsignal = gxi2.getExpectedSignal(j, 0., A);
      Vector aexpsig = SOPHYA::abs(expsignal);
      double mine, maxe;
      aexpsig.MinMax(mine, maxe);
      A=maxs/maxe;
      v_amp[j]=A; 
    }

691
    double fparm[500];  fparm[0]=0.;
692 693 694 695 696

    double bestxi2 = 9.e19;
    double bestphase=0.;
    int bestnpts,npts;
    int bestafact;
697
    double afact[12]={0.15,0.3,0.5,0.75,1.0,1.25,1.5,1.75,2.0,2.4,2.8,3.2};
698 699 700
    for(int ia=0; ia<12; ia++) {
      for(size_t j=0; j<NTRK; j++) {
	double Aac=sqrt(v_A[Anum1[ii]][j] * v_A[Anum2[ii]][j]);
701 702
	//DBG	cout << " *DBG* j="<<j<<" ia="<<ia<<" vA="<<v_A[Anum1[ii]][j]<<" x "<<v_A[Anum2[ii]][j]
	//     <<"  -> "<<Aac<<endl;
703
	fparm[2+3*j]=(useAac?Aac:v_amp[j]);
704
	fparm[2+3*j]*=afact[ia];   fparm[3+3*j]=fparm[4+3*j]=0.;
705 706 707
      }
      for(double ph=0.; ph<360.; ph += 1) {
	fparm[0]=Angle(ph, Angle::Degree).ToRadian();
708
	fparm[1]=0.;
709
	double xi2 = gxi2.getXi2(fparm, npts);
710
	//DBG	cout << " *DBG* ia="<<ia<<" afact="<<afact[ia]<<" ph="<<ph<<" xi2="<<xi2<<endl;
711 712 713 714 715
	if (xi2 < bestxi2) {
	  bestxi2 = xi2; bestphase=fparm[0]; bestnpts=npts;  bestafact=afact[ia];
	}
      }
    }
716
    mFit.SetParam(0,"Phi_0",bestphase,M_PI/720.,-0.5*M_PI,2.5*M_PI);
717 718
    cout << "2."<<ii+1<<" Scan param bestxi2_red="<<bestxi2/(double)(tot_npoints_fit-(1+NTRK))<<"  bestphase="
	 <<Angle(bestphase).ToDegree()<<" bestnpts="<<bestnpts<<" bestafact="<<bestafact<< " A= ";  
719
    v_phi_0[ii]=bestphase;
720 721
    for(size_t j=0; j<NTRK; j++)  {
      cout << v_amp[j] << " , ";  
722
      double Aac=sqrt(v_A[Anum1[ii]][j] * v_A[Anum2[ii]][j]);
723 724 725 726 727 728 729 730 731
      v_Acx[ii][j]=(useAac?Aac:v_amp[j]);
    }
    cout << endl;
    for(size_t j=0; j<NTRK; j++) {
      char pname[32];
      sprintf(pname,"A%d",(int)(j+1));
      double Aac=sqrt(v_A[Anum1[ii]][j] * v_A[Anum2[ii]][j]);
      double A=(useAac?Aac:v_amp[j]);
      //DBG      cout << "*DBG* j="<<j<<" Aac= "<<Aac<<" v_amp="<<v_amp[j]<<"  A= "<<A<<"  A1="<<v_A[Anum1[ii]][j]<<" A2="<<v_A[Anum2[ii]][j]<<endl;
732
      mFit.SetParam(2+3*j,pname,A,A/10.,A/4,A*4);
733 734
      sprintf(pname,"Bre%d",(int)(j+1));
      mFit.SetParam(3+3*j,pname,0.,A/25.,-A/5,A/5.);
735 736
      sprintf(pname,"Bim%d",(int)(j+1));
      mFit.SetParam(4+3*j,pname,0.,A/25.,-A/5,A/5.);
737
      mFit.SetFix(3+3*j,0.);
738
      mFit.SetFix(4+3*j,0.);
739 740 741 742
    }
    //DBG mFit.PrintFit();
    if (_prtlevel_>1)    
      cout << " 3."<<ii+1<<" Performing the fit for CrossCor " << ii << " FxF= " << Anum1[ii]+1<<"x"<<Anum2[ii]+1<<endl;
743
    int rcfit = mFit.doFit();
744 745 746 747 748
    v_RcFit_cx[ii]=rcfit;   v_xi2red_cx[ii]=-99999.;
    if (_prtlevel_>1) mFit.PrintFit();
    if(rcfit>0) { 
      v_xi2red_cx[ii]=mFit.GetChi2Red();
      //      cout<< "-------------------------- Result for Cross No " << ii << endl; 
749
      cout<< "------ Fit result for Cross No "<<ii+1<<" Reduce_Chisquare = " << mFit.GetChi2Red()
750 751 752 753 754 755 756
	  << " nstep="<<mFit.GetNStep() << " rc="<<rcfit<<endl;
    }
    else {
      cout << "---Fit failed for "<<ii<<" Fit_Error, rc = " << rcfit << "  nstep="<<mFit.GetNStep()<<endl;
      ofr <<setw(4)<<ii+1<<" ERROR FIT RC="<<rcfit<<"  nstep="<<mFit.GetNStep()<<endl;
      if (_prtlevel_>0) mFit.PrintFitErr(rcfit);
    }
757 758

    ofr <<setw(4)<<ii+1<<" "<<setw(5)<<rcfit<<setw(8)<<mFit.GetChi2Red()<<" "; 
759 760 761 762 763 764 765 766 767 768 769 770
    double phi0=mFit.GetParm(0);   double err_phi0=mFit.GetParmErr(0);
    double aphi=mFit.GetParm(1);   double err_aphi=mFit.GetParmErr(1);
    // on calcule la phase ajustee pour la frequence de reference 1300 MHz 
    double phase=gxi2.getPhase4Freq(phi0,aphi,1300.);
    while (phase<0.) phase += 2.*M_PI;
    while (phase>2.*M_PI) phase -= 2.*M_PI;
    cout <<"Phase(@1300MHz)= "<<setw(10)<<Angle(phase).ToDegree()<<"  phi_0= "<<setw(10)
	 <<Angle(phi0).ToDegree()<<" +/- "<<setw(10)<<Angle(err_phi0).ToDegree()<<" deg."
	 <<" a_phi= "<<setw(8)<<Angle(aphi).ToDegree()<<" +/- "<<setw(10)
	 <<Angle(err_aphi).ToDegree()<<" deg/250 MHz"<<endl;
    ofr <<setw(8)<<Angle(phi0).ToDegree()<<" "<<setw(8)<<Angle(err_phi0).ToDegree()<<"  "
	<<setw(8)<<Angle(aphi).ToDegree()<<" "<<setw(8)<<Angle(err_aphi).ToDegree()<<"  ";
771
    v_phase[ii]=phase;
772 773 774 775
    v_phi_0[ii]=phi0;
    v_err_phi_0[ii]=err_phi0;
    v_a_phi[ii]=aphi;
    v_err_a_phi[ii]=err_aphi;
776 777 778
    for(size_t j=0; j<NTRK; j++) {
      double Aac=sqrt(v_A[Anum1[ii]][j] * v_A[Anum2[ii]][j]);
      double Ai=(useAac?Aac:v_amp[j]);
779
      double A=mFit.GetParm(2+3*j);   double err_A=mFit.GetParmErr(2+3*j);
780 781 782 783 784 785
      cout << "  Trk["<<j<<"]  A= "<<A<<" +/- "<<err_A<<"  (A/Ai="<<A/Ai<<")"<<endl;
      v_Acx[ii][j]=A;  
      v_Bcx[ii][j]=complex<double>(0.,0.);
      v_err_Acx[ii][j]=err_A; 
      ofr <<setw(8)<<A<<" "<<setw(8)<<err_A<<" "; 
    }
786
    ofr << endl; 
787
  }
788 789 790 791 792 793 794 795 796 797 798
  cout << " --- Fitted phases: ";
  for(size_t i=0; i<NB_CXCORS; i++) cout<<setw(6)<<Angle(v_phase[i]).ToDegree()<<" ; ";   cout<<endl;
  double dphi23=v_phase[1]-v_phase[0];   if (dphi23<0.) dphi23+=(2.*M_PI);
  double dphi24=v_phase[2]-v_phase[0];   if (dphi24<0.) dphi24+=(2.*M_PI);
  double dphi34=v_phase[2]-v_phase[1];   if (dphi34<0.) dphi34+=(2.*M_PI);
  cout<<" Cx-2x3: "<<setw(6)<<Angle(dphi23).ToDegree()<<" ==? "<<setw(6)<<Angle(v_phase[3]).ToDegree()<<endl;
  cout<<" Cx-2x4: "<<setw(6)<<Angle(dphi24).ToDegree()<<" ==? "<<setw(6)<<Angle(v_phase[4]).ToDegree()<<endl;
  cout<<" Cx-3x4: "<<setw(6)<<Angle(dphi34).ToDegree()<<" ==? "<<setw(6)<<Angle(v_phase[5]).ToDegree()<<endl;
  ofr<<"# Cx-2x3: "<<setw(6)<<Angle(dphi23).ToDegree()<<" ==? "<<setw(6)<<Angle(v_phase[3]).ToDegree()<<endl;
  ofr<<"# Cx-2x4: "<<setw(6)<<Angle(dphi24).ToDegree()<<" ==? "<<setw(6)<<Angle(v_phase[4]).ToDegree()<<endl;
  ofr<<"# Cx-3x4: "<<setw(6)<<Angle(dphi34).ToDegree()<<" ==? "<<setw(6)<<Angle(v_phase[5]).ToDegree()<<endl;
799 800
  fit_cx_done=true;
  acxd_.v_cxbeams=v_cxbeams;
801
  acxd_.v_phase=v_phase;
802 803
  acxd_.v_phi_0=v_phi_0;
  acxd_.v_a_phi=v_a_phi;
804 805
  acxd_.v_Acx=v_Acx;
  acxd_.v_Bcx=v_Bcx;
806 807
  return 0;
} 
808

809

810 811 812 813 814 815 816 817 818 819 820
int ACxSetFitter::saveExpectedCx(string outcheckfilename)
{
  cout << "ACxSetFitter::saveExpectedCx() saving expected cross-cor (and visi-data) to file "<<outcheckfilename<<endl;
  POutPersist pox(outcheckfilename);
  size_t NB_CXCORS=acxd_.getNbCrossCor();
  size_t NTRK = acxd_.NbTrk();

  char oname[32];

  for(size_t ii=0; ii<NB_CXCORS; ii++) {
    CxBeam cxbeam=v_cxbeams[ii];
821
    MyCxSignal cxsig( acxd_.v_time_data, acxd_.vv_cxdata, acxd_.vv_cxerr, acxd_.v_freqs, 
822 823 824 825 826
		      tks_.v_interp_elev, tks_.v_interp_sazim, cxbeam, ii);
    for(size_t j=0; j<NTRK; j++) {
      TVector< complex<double> >  signal = cxsig.getDataSignal(j);
      sprintf(oname,"cx_%d_%d",(int)ii+1,(int)j+1);
      pox << PPFNameTag(oname)<<signal;
827 828 829
      //DBG      cout << " *DBG* getPhase4Freq() phi0="<<acxd_.v_phi_0[ii]<<" a_phi="<<acxd_.v_a_phi[ii]<<" freq="<<acxd_.v_freqs[j]<<endl;
      double phase=cxsig.getPhase4Freq(acxd_.v_phi_0[ii],acxd_.v_a_phi[ii],acxd_.v_freqs[j]);
      TVector< complex<double> >  expsignal = cxsig.getExpectedSignal(j, phase, v_Acx[ii][j]);
830 831 832 833 834 835 836 837 838 839 840
      sprintf(oname,"simcx_%d_%d",(int)ii+1,(int)j+1);
      pox << PPFNameTag(oname)<<expsignal;
      if (ii==0)  {
	Vector tmvec = cxsig.getTimeVec(j);
	sprintf(oname,"tim_%d",(int)j+1);
	pox << PPFNameTag(oname)<<tmvec;
      }
    }
  }
  return 0;
}  
841 842 843

//------------------------ CxBaselineFitter -------------------------------------
CxBaselineFitter::CxBaselineFitter(vector<AcxDataSet> & v_data, vector<TrackSet> & v_tks)
844 845
  : v_acxd(v_data), v_trks(v_tks), tot_ntrks(0), fit_done(false), simplex_done(false), 
    xi2red(-9.e9), bestfitparam(NULL), err_bestfitparam(NULL)
846 847 848 849 850
{
  if (v_acxd.size() != v_trks.size())
    throw ParmError("CxBaselineFitter::CxBaselineFitter(v_data, v_tks) NOT same size v_data,v_tks ");
  if (v_acxd.size() < 1)
    throw ParmError("CxBaselineFitter::CxBaselineFitter(v_data, v_tks) v_data.size()<1 ");
851
  
852 853 854 855 856
  tot_ntrks=0;
  for(size_t i=0; i<v_acxd.size(); i++) tot_ntrks+=v_acxd[i].NbTrk();
  if (tot_ntrks<1)
    throw ParmError("CxBaselineFitter::CxBaselineFitter(v_data, v_tks) 0 tracks ! tot_ntrks<1 ");

857
  size_t nparam = 5*(v_acxd[0].getNbAutoCor()-1);  // 5 param / antenne , phi0, aphi, dX,dY,dZ
858 859
  bestfitparam = new double[nparam];
  err_bestfitparam = new double[nparam];
860 861

  initFitParams();
862 863
}

864 865 866 867 868
CxBaselineFitter::~CxBaselineFitter()
{
  if (bestfitparam) delete[] bestfitparam;
  if (err_bestfitparam) delete[] err_bestfitparam;
}
869

870 871
void CxBaselineFitter::initFitParams()
{
872
  //DBG  cout << " *DBG* CxBaselineFitter::initFitParams() v_acxd[0].v_phase.size()="<<v_acxd[0].v_phase.size()<<endl;
873 874 875 876
  size_t NB_ANTENNES=v_acxd[0].getNbAutoCor();   // nombre d'antennes 
  size_t NB_CXCORS=v_acxd[0].getNbCrossCor();
  if (NB_ANTENNES != 4)
    throw PError("CxBaselineFitter::initFitParams() NB_ANTENNES != 4  Current version works only for 4 antenna");
877 878 879 880
  v_phi_0.resize(v_acxd[0].getNbAutoCor()-1);
  v_err_phi_0.resize(NB_ANTENNES-1);
  v_a_phi.resize(v_acxd[0].getNbAutoCor()-1);
  v_err_a_phi.resize(NB_ANTENNES-1);
881 882 883
  v_baselineshits.resize(NB_ANTENNES-1);
  v_err_baselineshits.resize(NB_ANTENNES-1);
  for(size_t i=0; i<(NB_ANTENNES-1); i++) {
884 885
    v_phi_0[i]=v_acxd[0].v_phi_0[i];   v_err_phi_0[i]=0.;
    v_a_phi[i]=v_acxd[0].v_a_phi[i];   v_err_a_phi[i]=0.;
886 887
    v_baselineshits[i]=Vector3d(0.,0.,0.);
    v_err_baselineshits[i]=Vector3d(0.,0.,0.);
888 889 890 891
    bestfitparam[2*i]=v_phi_0[i];
    err_bestfitparam[2*i]=0.;
    bestfitparam[2*i+1]=v_a_phi[i];
    err_bestfitparam[2*i]=0.;
892 893 894 895
    for(size_t j=0; j<3; j++) {
      bestfitparam[3*(i+1)+j]=err_bestfitparam[3*(i+1)+j]=0.;
    }
  }
896 897
  //DBG  cout << " *DBG* DONE **** CxBaselineFitter::initFitParams()"<<endl;

898 899
}

900
int CxBaselineFitter::dofit(string outfilename, bool fgfixbaseline, bool fgphi0only)
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
{
  size_t NB_ANTENNES=v_acxd[0].getNbAutoCor();   // nombre d'antennes 
  size_t NB_CXCORS=v_acxd[0].getNbCrossCor();
  cout << "======================================================================================"<<endl;
  cout << "------- CxBaselineFitter::dofit()  Performing baseline/phase fit on the 6 cross-cors "<<" TotNbTracks="<<tot_ntrks<<endl;
  
  ofstream ofr(outfilename.c_str());
  ofr << "####  Fitted phases and baseline-shifts (CxBaselineFitter::dofit() ) "<<endl
      << "## NumAntenna  Phase BaselineShiftX  BaselineShiftY BaselineShiftZ  (Phase in degree, BaselineShift in meter) "<<endl;

  int tot_npoints_fit = 0;
  for(size_t i=0; i<v_acxd.size(); i++)
    for(size_t j=0; j<v_acxd[i].NbTrk(); j++)
      tot_npoints_fit += 2*(v_acxd[i].v_time_data[j].size())*NB_CXCORS;
  cout << " Total number of data points for fit="<< tot_npoints_fit<<endl;
  GeneralFitData gdata(1, tot_npoints_fit);
917
  int npoints2=0;
918 919 920 921 922
  for(size_t i=0; i<v_acxd.size(); i++)
    for(size_t kcx=0; kcx<NB_CXCORS; kcx++) {
      for(size_t j=0; j<v_acxd[i].NbTrk(); j++)  {
	vector< vector< complex<double> > > & v_cxdata = v_acxd[i].vv_cxdata[j];
	vector< vector<double> > & v_cxerr = v_acxd[i].vv_cxerr[j];
923
	for(size_t l=0; l<v_acxd[i].v_time_data[j].size(); l++) {
924
	  gdata.AddData1(v_acxd[i].v_time_data[j][l],v_cxdata[kcx][l].real(),v_cxerr[kcx][l]); // Fill x, y and error on y
925 926
	  gdata.AddData1(v_acxd[i].v_time_data[j][l],v_cxdata[kcx][l].imag(),v_cxerr[kcx][l]); // Fill x, y and error on y
	  npoints2+=2;
927 928 929 930
	}
      }
    }

931 932 933 934
  TkF_6CxXi2B gxi2(v_acxd, v_trks);   // My6CxGenXi2B
  //  GeneralFit mFit(&gxi2);
  TkF_Fitter mFit(gxi2);

935
  mFit.SetData(&gdata);        // connect data to the fitter , here the data is unused - gxi2 includes its data 
936
  mFit.SetMaxStep(3000);
937 938 939 940
  
  // SetParam(int n,double value, double step,double min=1., double max=-1.);
  for(size_t i=0; i<(NB_ANTENNES-1); i++) {
    char pname[32];
941 942 943 944 945 946
    sprintf(pname,"Phi0_%d",(int)(i+2));
    mFit.SetParam(2*i,pname,v_phi_0[i],M_PI/180.,0.,2.5*M_PI);
    sprintf(pname,"a_Phi_%d",(int)(i+2));
    mFit.SetParam(2*i+1,pname,v_a_phi[i],0.1,-15.,15.);
    if (fgphi0only)  mFit.SetFix(2*i+1, 0.);
    v_err_phi_0[i]=0.;  v_err_a_phi[i]=0.;
947
    sprintf(pname,"BaselineShift_X_%d",(int)(i+2));
948
    mFit.SetParam(6+3*i,pname,v_baselineshits[i].X(),0.02,-0.25,0.25);
949
    sprintf(pname,"BaselineShift_Y_%d",(int)(i+2));
950
    mFit.SetParam(7+3*i,pname,v_baselineshits[i].Y(),0.02,-0.25,0.25);
951
    sprintf(pname,"BaselineShift_Z_%d",(int)(i+2));
952
    mFit.SetParam(8+3*i,pname,v_baselineshits[i].Z(),0.02,-0.25,0.25);
953 954
    if (fgfixbaseline) {
      cout << " ... fitting phases only, fixed baselines "<<endl;
955
      mFit.SetFix(6+3*i); mFit.SetFix(7+3*i);  mFit.SetFix(8+3*i);
956
    }
957
  }
958
  cout << " Performing the fit (tot_npoints_fit= "<<tot_npoints_fit<<" ?= (npoints2="<<npoints2<<") ..."<< endl;
959
  rcfit = mFit.doFit();  xi2red=-99999.;
960 961 962
  cout<< "------ Fit result Reduce_Chisquare = " << mFit.GetChi2Red()<< " nstep="<<mFit.GetNStep() << " rc="<<rcfit<<endl;
  mFit.PrintFit();

963 964 965 966 967 968 969
  for(size_t j=0; j<4; j++) 
    for(size_t i=0; i<(NB_ANTENNES-1); i++) {
      bestfitparam[j*3+i]=mFit.GetParmErr(j*3+i);
      err_bestfitparam[j*3+i]=mFit.GetParmErr(j*3+i);
    }

  for(size_t i=0; i<(NB_ANTENNES-1); i++) {
970 971 972 973 974 975 976 977 978 979
    v_phi_0[i]=mFit.GetParm(2*i);      
    v_err_phi_0[i]=mFit.GetParmErr(2*i);
    v_a_phi[i]=mFit.GetParm(2*i+1);      
    v_err_a_phi[i]=mFit.GetParmErr(2*i+1);
    double xs=mFit.GetParm(i*3+6);  
    double exs=mFit.GetParmErr(i*3+6);  
    double ys=mFit.GetParm(i*3+7);  
    double eys=mFit.GetParmErr(i*3+7);  
    double zs=mFit.GetParm(i*3+8);  
    double ezs=mFit.GetParmErr(i*3+8);  
980 981 982 983
    v_baselineshits[i]=Vector3d(xs,ys,zs);
    v_err_baselineshits[i]=Vector3d(exs,eys,ezs);

  }
984 985 986
  fit_done=true;
  return 0;
}
987

988 989 990 991 992 993 994 995 996 997
int CxBaselineFitter::doSimplexMinimize()
{
  size_t NB_ANTENNES=v_acxd[0].getNbAutoCor();   // nombre d'antennes 
  size_t NB_CXCORS=v_acxd[0].getNbCrossCor();
  cout << "======================================================================================"<<endl;
  cout << "------- CxBaselineFitter::doSimplexMinimize()  Performing baseline/phase determination using the 6 cross-cors "<<" TotNbTracks="<<tot_ntrks<<endl;

  if (NB_ANTENNES != 4)
    throw PError("CxBaselineFitter::doSimplexMinimize() NB_ANTENNES != 4  Current version works only for 4 antenna");

998
  My6CxMinZFunc mzfunc(v_acxd, v_trks, true); 
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
  MinZSimplex simplex(&mzfunc);
  // Guess the center and step for constructing the initial simplex
  size_t nparam = 4*(NB_ANTENNES-1);
  Vector P0(nparam); 
  Vector step(nparam);
  for(size_t i=0; i<(NB_ANTENNES-1); i++) {
    P0(i)=v_acxd[0].v_phase[i];
    step(i)=M_PI/6.;
    for(size_t j=0;j<3;j++) {
      P0((i+1)*3+j)=0.;
      step((i+1)*3+j)=0.05;
    }
  }
  cout << " Initial Point: "<<P0.Transpose()<<endl;
  cout << " Initial Step: "<<step.Transpose()<<endl;
  cout << "  Initial Xi2= " << mzfunc.Value(P0.Data())<<endl;

  simplex.SetInitialPoint(P0);
  simplex.SetInitialStep(step);
  simplex.SetPrtLevel(_prtlevel_);
  Vector oparm(nparam);
  int rc = simplex.Minimize(oparm);
  if (rc != 0) {
    string srt; 
    int sr = simplex.StopReason(srt);
    cout << " Convergence Pb, StopReason= " << sr << " : " << srt << endl;
  }
  else {
    cout << " Converged: NStep= " << simplex.NbIter() << " Best Xi2="<<  mzfunc.Value(oparm.Data()) << endl;
    simplex_done=true;
    for(size_t i=0; i<(NB_ANTENNES-1); i++) {
1030
      v_phi_0[i]=oparm(i);      
1031 1032 1033 1034
      double xs=oparm(i*3+3);  
      double ys=oparm(i*3+4);  
      double zs=oparm(i*3+5);  
      v_baselineshits[i]=Vector3d(xs,ys,zs);
1035
      cout << " ANTENNE["<<i+2<<"] : Phase="<<v_phi_0[i]<<" BaseLineShift="<<v_baselineshits[i]<<endl;
1036 1037 1038 1039 1040 1041
    }
  }

  return 0;
}

1042
int CxBaselineFitter::doCheck()
1043 1044 1045 1046 1047