measuredstar.h

Go to the documentation of this file.

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

#include <basestar.h>
#include <iostream>


#include "fittedstar.h" // for FittedStarRef
#include "preferences.h"


class SEStar;
class CcdImage;
class ReducedImage;
class fastifstream;

class MeasuredStar : public BaseStar
{
  public :
  double mag;
  double wmag;
  double eflux;
  double aperrad;
  double chi2;
  
  
  const CcdImage *ccdImage;
  std::vector<double> usrVals;
  
  private :
    bool   valid;

    FittedStarRef fittedStar;
  
  public :
    
  MeasuredStar() 
    : BaseStar(),
      mag(0.), wmag(0.), eflux(0.), aperrad(0.), 
      ccdImage(0),
      fittedStar((const FittedStar*)NULL), 
      valid(true) {}
  
  MeasuredStar(const BaseStar &B, const FittedStar *F = NULL) : 
    BaseStar(B), 
    mag(0.), wmag(0.), eflux(0.), aperrad(0.), 
    ccdImage(0),
    fittedStar(F),
    valid(true)
    
  {
    //    InitialStarRef = &B;
  }

  MeasuredStar( const SEStar &S);

  void SetFittedStar(FittedStar *F) 
      { if (F)  F->MeasurementCount()++; fittedStar = F;
      }

  double FluxSig() const { return eflux;}

  double Mag() const { return mag;}
  double AperRad() const { return aperrad; }
  
  double MagWeight() const { return (flux*flux/(eflux*eflux));}

  const FittedStar* GetFittedStar() const { return fittedStar;};

  FittedStar* GetFittedStar()  { return fittedStar;};

  const CcdImage &GetCcdImage()  const { return *ccdImage;};

  void SetCcdImage(const CcdImage *C) { ccdImage = C;};
  
  bool  IsValid() const { return valid; }
  void  SetValid(bool v) { valid=v; }
  
  // No longer decrement counter of associated fitted star in destructor (P. El-Hage le 10/04/2012)
  // ~MeasuredStar() { if (fittedStar) fittedStar->MeasurementCount()--;}

  std::string WriteHeader_(std::ostream & pr = std::cout, const char* i = NULL) const;
  void writen(std::ostream& s) const;
  static BaseStar*  read(fastifstream& s, const char* format);
};


typedef CountedRef<MeasuredStar> MeasuredStarRef;




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

class MeasuredStarList : public StarList<MeasuredStar> {

  double zeroPoint;

  public :
    MeasuredStarList() {};
  

  void SetZeroPoint(const double &ZP);

  void SetCcdImage(const CcdImage *C);
};



typedef MeasuredStarList::const_iterator MeasuredStarCIterator;
typedef MeasuredStarList::iterator MeasuredStarIterator;
typedef CountedRef<MeasuredStar> MeasuredStarRef;

BaseStarList& Measured2Base(MeasuredStarList &This);
BaseStarList* Measured2Base(MeasuredStarList *This);
const BaseStarList& Measured2Base(const MeasuredStarList &This);
const BaseStarList* Measured2Base(const MeasuredStarList *This);




typedef bool (CatalogLoader_(const ReducedImage &R, const CcdImage &, MeasuredStarList &List));

class CatalogLoader{
  CatalogLoader_ * loader;
public:
  CatalogLoader(CatalogLoader_  *l){
    loader = l;
  }
  bool operator()(const ReducedImage & ri,
              const CcdImage & ccdim, 
              MeasuredStarList & stl) const{
    return load(ri, ccdim, stl);
  }
  virtual bool load(const ReducedImage & ri,
            const CcdImage & ccdim, 
            MeasuredStarList & stl) const{
    return (*loader)(ri, ccdim, stl);
  }

  virtual ~CatalogLoader(){};

  static CatalogLoader * DefaultCatalogLoader;
  static CatalogLoader * getDefaultCatalogLoader();
   
protected:
  CatalogLoader(){}
};

bool KeepSEStar(const SEStar &S);

extern const CatalogLoader &AperSELoader_Minimal_NormalizeFluxes;
extern const CatalogLoader &AperSELoader_SelectStars_NormalizeFluxes;
extern const CatalogLoader &SELoader_SelectStars_NormalizeFluxes;
extern const CatalogLoader &AperSELoader_NormalizeFluxes;
extern const CatalogLoader &AperSELoader_SelectStars_NormalizeFluxes_nosncut;
extern const CatalogLoader &CachedMeasuredStarLoader;
extern const CatalogLoader &MCMeasuredStarLoader;


void SelectFluxForFitCatalog(std::string const& filename);
//void ConvertCatalogFluxesToMagnitudes(bool convert /*, double zp=0. */);

#endif /* MEASUREDSTAR__H */