fittedstar.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef FITTEDSTAR__H
#define FITTEDSTAR__H



#include <basestar.h>

class fastifstream;


class MeasuredStar;
class RefStar;
class Gtransfo;


struct PmBlock
{
// proper motion in x and y. Units depend on how you fit them
  double pmx,pmy;
  double epmx, epmy, epmxy;
  double color; // OK it is unrelated, but associated in practice
  bool mightMove;


  PmBlock() : pmx(0), pmy(0), epmx(0), epmy(0), epmxy(0), color(0), mightMove(false) {};

  

};

class FittedStar : public BaseStar, public PmBlock {

  friend class PhotomFit;
  friend class PhotomFit2;


  private:

  double mag;
  double emag;
  double col;
  int    gen;
  double wmag;
  unsigned indexInMatrix; 
  int measurementCount;
  const RefStar *refStar;
  
  double flux2;
  double fluxErr;
  double fluxErr2;

 public:
  FittedStar() : 
    BaseStar(), mag(-1), emag(-1), col(0.), gen(-1), wmag(0), 
    indexInMatrix(-1), measurementCount(0), refStar(NULL),
    flux2(-1), 
    fluxErr(-1),
    fluxErr2(-1) {}
  
  FittedStar(const BaseStar &B) : 
    BaseStar(B), mag(-1), emag(-1), col(0.), gen(-1), wmag(0), 
    indexInMatrix(0), measurementCount(0), refStar(NULL),
    flux2(-1), 
    fluxErr(-1),
    fluxErr2(-1) {}
    
  //  FittedStar(const FittedStar& F)
  //    : BaseStar(F), mag(F.mag), emag(F.emag), col(F.col), gen(F.gen), wmag(F.wmag),
  //      index(F.index), measurementCount(F.measurementCount), refStar(F.refStar),
  //      flux2(F.flux2), fluxErr(F.fluxErr), fluxErr2(F.fluxErr2) {}
    
  FittedStar(const MeasuredStar &M);


  void ClearBeforeAssoc()
  {
    indexInMatrix = -1;
    measurementCount = 0;
    refStar = NULL;
    wmag = 0;
  }
  

  void dump(std::ostream & stream = std::cout) const
    { BaseStar::dumpn(stream); 
    stream << " mcount " 
       << measurementCount << std::endl;
    }

  int MeasurementCount() const { return measurementCount;}

  int& MeasurementCount() { return measurementCount;}

  double Mag() const { return mag;}
  double& Mag() { return mag; }
  double EMag() const { return emag;}
  double& EMag() { return emag; }
  double Col() const { return col;}
  double& Col() { return col; }
  int     Generation() const { return gen;}
  int&    Generation() { return gen; }

  void  SetMag(double Value) { mag = Value;}

  void AddMagMeasurement(const double &MagValue, 
             const double &MagWeight);

  void SetIndexInMatrix(const unsigned &Index){ indexInMatrix = Index;};

  int  IndexInMatrix() const { return indexInMatrix;}

  void SetRefStar(const RefStar &);

  const RefStar *GetRefStar() const { return refStar;};
  
  double         Flux() const { return flux; }
  double&        Flux() { return flux; }
  double         FluxErr() const { return fluxErr; }
  double&        FluxErr() { return fluxErr; }
  
  double         Flux2() const { return flux2; }
  double&        Flux2() { return flux2; }
  double         FluxErr2() const { return fluxErr2; }
  double&        FluxErr2() { return fluxErr2; }
  
  std::string       WriteHeader_(std::ostream& pr=std::cout, const char* i=NULL) const;
  virtual void      writen(std::ostream& s) const;
  virtual void      read_it(fastifstream& s, const char* format);
  static BaseStar*  read(fastifstream& s, const char* format);
};


/****** FittedStarList */
#include "starlist.h"


class FittedStarList : public  StarList<FittedStar>
{
 
  public :

  bool  inTangentPlaneCoordinates;

  FittedStarList() {inTangentPlaneCoordinates=true;}

    FittedStarList(const std::string &FileName);
    
    void WriteTuple(const std::string &FileName, 
            const Gtransfo &TP2RaDec,
            const bool OnlyGoodStars = true);


};
 
typedef FittedStarList::const_iterator FittedStarCIterator;
typedef FittedStarList::iterator FittedStarIterator;
typedef CountedRef<FittedStar> FittedStarRef;

BaseStarList& Fitted2Base(FittedStarList &This);
BaseStarList* Fitted2Base(FittedStarList *This);
const BaseStarList& Fitted2Base(const FittedStarList &This);
const BaseStarList* Fitted2Base(const FittedStarList *This);


#include <fstream>


class FittedStarTuple {
  private :
  std::ofstream stream;

  public :
    FittedStarTuple( const std::string &FileName);


  void AddEntry(const FittedStar &F, const Point &RaDec);

  ~FittedStarTuple() { stream.close();}
};


#endif /* FITTEDSTAR__H */