compass/rc/sutra__source_8h_source.html

// -----------------------------------------------------------------------------

//  This file is part of COMPASS <https://anr-compass.github.io/compass/>

//

//  Copyright (C) 2011-2019 COMPASS Team <https://github.com/ANR-COMPASS>

//  All rights reserved.

//  Distributed under GNU - LGPL

//

//  COMPASS is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser

//  General Public License as published by the Free Software Foundation, either version 3 of the License,

//  or any later version.

//

//  COMPASS: End-to-end AO simulation tool using GPU acceleration

//  The COMPASS platform was designed to meet the need of high-performance for the simulation of AO systems.

//

//  The final product includes a software package for simulating all the critical subcomponents of AO,

//  particularly in the context of the ELT and a real-time core based on several control approaches,

//  with performances consistent with its integration into an instrument. Taking advantage of the specific

//  hardware architecture of the GPU, the COMPASS tool allows to achieve adequate execution speeds to

//  conduct large simulation campaigns called to the ELT.

//

//  The COMPASS platform can be used to carry a wide variety of simulations to both testspecific components

//  of AO of the E-ELT (such as wavefront analysis device with a pyramid or elongated Laser star), and

//  various systems configurations such as multi-conjugate AO.

//

//  COMPASS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the

//  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

//  See the GNU Lesser General Public License for more details.

//

//  You should have received a copy of the GNU Lesser General Public License along with COMPASS.

//  If not, see <https://www.gnu.org/licenses/lgpl-3.0.txt>.

// -----------------------------------------------------------------------------


#ifndef _SUTRA_SOURCE_H_

#define _SUTRA_SOURCE_H_


#include <carma.h>

#include <sutra_atmos.h>

#include <sutra_dm.h>

#include <sutra_lgs.h>

#include <sutra_source.h>

#include <sutra_telemetry.h>

#include <sutra_telescope.h>

#include <sutra_utils.h>

#include <map>

#include <string>

#include <vector>


using std::map;

using std::string;


typedef std::pair<std::string, int> type_screen;


class SutraSource {

 public:

  CarmaContext *current_context;

  int device;

  float posx;

  float posy;

  long npts;

  float mag;

  float lambda;

  float zp;

  float scale;

  bool lgs;

  float G;

  float thetaML;

  float dx;

  float dy;

  string type;

  int block_size;


  float strehl_se;

  float strehl_le;

  float ref_strehl;

  int strehl_counter;

  float phase_var;

  float phase_var_avg;

  int phase_var_count;


  SutraPhase *d_phase;

  // INTRO PHASE INSTRU

  // SutraPhase *d_phase_instru;

  CarmaHostObj<float> *phase_telemetry;

  SutraLGS *d_lgs;

  CarmaObj<float> *d_pupil;

  CarmaObj<float> *d_image_se;

  CarmaObj<float> *d_image_le;

  CarmaObj<cuFloatComplex> *d_amplipup;

  CarmaObj<float> *d_phasepts;

  CarmaObj<int> *d_wherephase;

  map<type_screen, float> xoff;

  map<type_screen, float> yoff;

  CarmaObj<float> *d_ncpa_phase;

  CarmaObj<float> *d_smallimg;

  const int d_smallimg_size = 3;


 public:

  SutraSource(CarmaContext *context, float xpos, float ypos, float lambda,

               float mag, float zerop, long size, string type,

               CarmaObj<float> *pupil, int Npts, int device);

  SutraSource(CarmaContext *context, float xpos, float ypos, float lambda,

               float mag, float zerop, long size, string type, int device);

  ~SutraSource();

  inline int init_source(CarmaContext *context, float xpos, float ypos,

                         float lambda, float mag, float zerop, long size,

                         string type, int device);

  int add_layer(string type, int idx, float xoff, float yoff);

  int remove_layer(string type, int idx);

  // int get_phase(float *h_dest);

  int raytrace(SutraTelescope *tel, bool rst = false);

  int raytrace(SutraAtmos *atmos, bool async = false);

  int raytrace(SutraDms *ydms, bool rst = false, bool do_phase_var = true,

               bool async = false);

  int raytrace(SutraTelescope *tel, SutraAtmos *atmos, SutraDms *ydms,

               bool do_phase_var = true, bool async = false);

  int raytrace(bool rst = false);

  int raytrace_shm(SutraAtmos *atmos);

  int comp_image(int puponly = 0, bool comp_le = true);

  int init_strehlmeter();

  int reset_strehlmeter();

  int comp_strehl(bool do_fit);

  int reset_phase();


 private:

  float fitmax2x1dSinc(float *d_img, int ind_max, int img_size);

};


int target_raytrace(float *d_odata, float *d_idata, int nx, int ny, int Nx,

                    float xoff, float yoff, float G, float thetaML, float dx,

                    float dy, int block_size, float delta);

int target_raytrace_async(CarmaStreams streams, float *d_odata, float *d_idata,

                          int nx, int ny, int Nx, float xoff, float yoff,

                          int block_size);

int target_raytrace_async(CarmaHostObj<float> *phase_telemetry,

                          float *d_odata, float *d_idata, int nx, int ny,

                          int Nx, float xoff, float yoff, int block_size);

int fft_goodsize(long size);


// ATTEMPT AT ADDING PHASE_INSTRU

/*int

fill_amplipup(cuFloatComplex *amplipup, float *phase, float *phase_instru, float

*mask, float scale,

    int puponly, int nx, int ny, int Nx, CarmaDevice *device);*/


int fill_amplipup(cuFloatComplex *amplipup, float *phase, float *mask,

                  float scale, int puponly, int nx, int ny, int Nx,

                  CarmaDevice *device);


#endif  // _SUTRA_SOURCE_H_