00001 #ifndef CSPADPIXCOORDS_CSPADIMAGEPRODUCER_H
00002 #define CSPADPIXCOORDS_CSPADIMAGEPRODUCER_H
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "psana/Module.h"
00021 #include "MsgLogger/MsgLogger.h"
00022
00023
00024
00025
00026 #include "PSCalib/CSPadCalibPars.h"
00027
00028 #include "CSPadPixCoords/QuadParameters.h"
00029 #include "CSPadPixCoords/PixCoords2x1.h"
00030 #include "CSPadPixCoords/PixCoordsQuad.h"
00031 #include "CSPadPixCoords/PixCoordsCSPad.h"
00032
00033 #include "CSPadPixCoords/Image2D.h"
00034 #include "CSPadPixCoords/GlobalMethods.h"
00035
00036
00037
00038
00039
00040 #include "PSEvt/Source.h"
00041
00042
00043
00044
00045
00046
00047 using namespace std;
00048
00049 namespace CSPadPixCoords {
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081 typedef int16_t pixmap_cspad_t;
00082 typedef int32_t pixnum_cspad_t;
00083
00084
00085 class CSPadImageProducer : public Module {
00086 public:
00087
00088 enum { NQuadsMax = Psana::CsPad::MaxQuadsPerSensor };
00089 enum { N2x1 = Psana::CsPad::SectorsPerQuad };
00090 enum { NCols2x1 = Psana::CsPad::ColumnsPerASIC };
00091 enum { NRows2x1 = Psana::CsPad::MaxRowsPerASIC * 2 };
00092 enum { SizeOf2x1Arr = NRows2x1 * NCols2x1 };
00093 const static uint32_t ARR_SIZE=32*SizeOf2x1Arr;
00094
00095
00096 CSPadImageProducer (const std::string& name) ;
00097
00098
00099 virtual ~CSPadImageProducer () ;
00100
00101
00102 virtual void beginJob(Event& evt, Env& env);
00103
00104
00105 virtual void beginRun(Event& evt, Env& env);
00106
00107
00108 virtual void beginCalibCycle(Event& evt, Env& env);
00109
00110
00111
00112 virtual void event(Event& evt, Env& env);
00113
00114
00115 virtual void endCalibCycle(Event& evt, Env& env);
00116
00117
00118 virtual void endRun(Event& evt, Env& env);
00119
00120
00121 virtual void endJob(Event& evt, Env& env);
00122
00123
00124 protected:
00125
00126 void printInputParameters();
00127 void getConfigPars(Env& env);
00128 bool getGeometryPars(const std::string& calib_dir, const int runnum, const unsigned prbits);
00129 void getCalibPars(Event& evt, Env& env);
00130 void procEvent(Event& evt, Env& env);
00131 void getCSPadConfigFromData(Event& evt);
00132 void checkTypeImplementation();
00133 void cspadImgActivePixelMask(Env& env);
00134
00135
00136
00137
00138
00139
00140 private:
00141
00142
00143
00144 std::string m_calibDir;
00145 std::string m_typeGroupName;
00146 std::string m_str_src;
00147
00148 Source m_source;
00149 Pds::Src m_src;
00150 std::string m_inkey;
00151 std::string m_imgkey;
00152 std::string m_fname_pixmap;
00153 std::string m_fname_pixnum;
00154 std::string m_outtype;
00155 bool m_tiltIsApplied;
00156 unsigned m_print_bits;
00157 long m_count;
00158 long m_count_cfg;
00159 long m_count_msg;
00160 DATA_TYPE m_dtype;
00161
00162
00163 uint32_t m_numQuadsInConfig;
00164 uint32_t m_roiMask [4];
00165 uint32_t m_numAsicsStored [4];
00166
00167
00168 uint32_t m_numQuads;
00169 uint32_t m_quadNumber [4];
00170 uint32_t m_num2x1Stored [4];
00171
00172 PSCalib::CSPadCalibPars *m_cspad_calibpar;
00173 CSPadPixCoords::PixCoords2x1 *m_pix_coords_2x1;
00174 CSPadPixCoords::PixCoordsQuad *m_pix_coords_quad;
00175 CSPadPixCoords::PixCoordsCSPad *m_pix_coords_cspad;
00176
00177
00178 double *m_coor_x_pix;
00179 double *m_coor_y_pix;
00180 uint32_t *m_coor_x_int;
00181 uint32_t *m_coor_y_int;
00182
00183 const static int NX_QUAD=850;
00184 const static int NY_QUAD=850;
00185
00186 const static int NX_CSPAD=1750;
00187 const static int NY_CSPAD=1750;
00188 const static uint32_t IMG_SIZE=NX_CSPAD*NY_CSPAD;
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205 template <typename T>
00206 bool getQuadConfigParsForType(Env& env) {
00207
00208
00209
00210 shared_ptr<T> config = env.configStore().get(m_source, &m_src);
00211 if (config.get()) {
00212 for (uint32_t q = 0; q < NQuadsMax; ++ q) {
00213 m_roiMask[q] = config->roiMask(q);
00214 m_numAsicsStored[q] = config->numAsicsStored(q);
00215 }
00216 m_count_cfg ++;
00217 return true;
00218 }
00219 return false;
00220 }
00221
00222
00223
00224
00225
00226
00227
00228 template <typename TDATA, typename TELEMENT>
00229 bool getCSPadConfigFromDataForType(Event& evt) {
00230
00231
00232
00233 std::string key="";
00234
00235 shared_ptr<TDATA> data = evt.get(m_source, key, &m_src);
00236 if (data.get()) {
00237 m_numQuads = data->quads_shape()[0];
00238
00239 for (uint32_t q = 0; q < m_numQuads; ++ q) {
00240 const TELEMENT& el = data->quads(q);
00241 m_quadNumber[q] = el.quad();
00242 m_num2x1Stored[q] = el.data().shape()[0];
00243 }
00244 return true;
00245 }
00246 return false;
00247 }
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258 template <typename TIN, typename TOUT>
00259 void cspadImageFillForType(const TIN* data, CSPadPixCoords::QuadParameters* quadpars, ndarray<TOUT,2>& img_nda)
00260 {
00261 int quad = quadpars -> getQuadNumber();
00262 uint32_t roiMask = quadpars -> getRoiMask();
00263
00264 int ind_in_arr = 0;
00265
00266 for(uint32_t sect=0; sect < N2x1; sect++)
00267 {
00268 bool bitIsOn = roiMask & (1<<sect);
00269 if( !bitIsOn ) continue;
00270
00271 int pix_in_cspad = (quad*N2x1 + sect) * SizeOf2x1Arr;
00272
00273 const TIN *data2x1 = &data[ind_in_arr * SizeOf2x1Arr];
00274
00275
00276 for (uint32_t c=0; c<NCols2x1; c++) {
00277 for (uint32_t r=0; r<NRows2x1; r++) {
00278
00279
00280
00281
00282
00283
00284 int ix = m_coor_x_int [pix_in_cspad];
00285 int iy = m_coor_y_int [pix_in_cspad];
00286 pix_in_cspad++;
00287
00288 if(ix < 0) continue;
00289 if(iy < 0) continue;
00290 if(ix >= NX_CSPAD) continue;
00291 if(iy >= NY_CSPAD) continue;
00292
00293
00294
00295
00296 img_nda[ix][iy] += (TOUT)data2x1[c*NRows2x1+r];
00297 }
00298 }
00299 ++ind_in_arr;
00300 }
00301 }
00302
00303
00304
00305
00306
00307
00308
00309
00310 template <typename TDATA, typename TELEMENT>
00311 bool procCSPadDataForType (Event& evt) {
00312
00313 typedef int16_t data_cspad_t;
00314 typedef int16_t TOUT;
00315
00316
00317
00318 shared_ptr<TDATA> data_shp = evt.get(m_source, m_inkey, &m_src);
00319
00320 if (data_shp.get()) {
00321
00322 const unsigned shape[] = {NY_CSPAD,NX_CSPAD};
00323 ndarray<TOUT,2> img_nda(shape);
00324 std::fill(img_nda.begin(), img_nda.end(), TOUT(0));
00325
00326
00327
00328 int nQuads = data_shp->quads_shape()[0];
00329 for (int q = 0; q < nQuads; ++ q) {
00330 const TELEMENT& el = data_shp->quads(q);
00331 const ndarray<const data_cspad_t,3>& data_nda = el.data();
00332 uint32_t qNum = el.quad() ;
00333 CSPadPixCoords::QuadParameters *quadpars = new CSPadPixCoords::QuadParameters(qNum, NX_QUAD, NY_QUAD, m_numAsicsStored[qNum], m_roiMask[qNum]);
00334
00335 cspadImageFillForType<data_cspad_t, TOUT>(data_nda.data(), quadpars, img_nda);
00336 }
00337
00338
00339
00340 save2DArrayInEvent<TOUT>(evt, m_src, m_imgkey, img_nda);
00341
00342 return true;
00343 }
00344 return false;
00345 }
00346
00347
00348
00349
00350
00351
00352
00353
00354 template <typename T>
00355 void procCSPadNDArrForTypeAndNDArr (Event& evt, const ndarray<const T,3> inp_ndarr) {
00356
00357 const unsigned shape[] = {NY_CSPAD,NX_CSPAD};
00358 ndarray<T,2> img_nda(shape);
00359
00360 std::fill(img_nda.begin(), img_nda.end(), T(0));
00361
00362
00363
00364
00365 int ind2x1_in_arr = 0;
00366
00367 if (inp_ndarr.shape()[0] == 32) {
00368
00369 for (uint32_t q = 0; q < 4; ++ q) {
00370 const T* data_quad = &inp_ndarr[ind2x1_in_arr][0][0];
00371 CSPadPixCoords::QuadParameters *quadpars = new CSPadPixCoords::QuadParameters(q, NX_QUAD, NY_QUAD, 8, 255);
00372 cspadImageFillForType<T,T>(data_quad, quadpars, img_nda);
00373 ind2x1_in_arr += 8;
00374 }
00375 }
00376 else {
00377
00378 for (uint32_t q = 0; q < m_numQuads; ++ q) {
00379 const T* data_quad = &inp_ndarr[ind2x1_in_arr][0][0];
00380 uint32_t qNum = m_quadNumber[q];
00381 CSPadPixCoords::QuadParameters *quadpars = new CSPadPixCoords::QuadParameters(qNum, NX_QUAD, NY_QUAD, m_numAsicsStored[qNum], m_roiMask[qNum]);
00382
00383 cspadImageFillForType<T,T>(data_quad, quadpars, img_nda);
00384 ind2x1_in_arr += m_num2x1Stored[q];
00385 }
00386 }
00387
00388
00389 save2DArrayInEvent<T>(evt, m_src, m_imgkey, img_nda);
00390 }
00391
00392
00393
00394
00395
00396
00397
00398
00399 template <typename T>
00400 bool procCSPadNDArrForType (Event& evt) {
00401
00402 if( m_print_bits & 8 ) MsgLog(name(), info, "Produce image from CSPAD ndarray, source:" << m_source
00403 << " key:" << m_inkey << " data type:" << typeid(T).name() );
00404
00405 shared_ptr< ndarray<const T,3> > shp_const = evt.get(m_source, m_inkey, &m_src);
00406 if (shp_const.get()) { procCSPadNDArrForTypeAndNDArr<T>(evt, *shp_const.get()); return true; }
00407
00408 shared_ptr< ndarray<T,3> > shp = evt.get(m_source, m_inkey, &m_src);
00409 if (shp.get()) { procCSPadNDArrForTypeAndNDArr<T>(evt, *shp.get()); return true; }
00410
00411 return false;
00412 }
00413
00414
00415
00416 };
00417
00418 }
00419
00420 #endif // CSPADPIXCOORDS_CSPADIMAGEPRODUCER_H