Ignore:
Timestamp:
10/12/04 14:43:18 (20 years ago)
Author:
moralejo
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Simulation/Detector/StarResponse
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Simulation/Detector/StarResponse/MStarLight.cxx

    r5099 r5248  
    33using namespace std;
    44
    5 MStarLight::MStarLight() {
     5MStarLight::MStarLight(Float_t fadc_slices_per_ns, Int_t response_slices_fadc) {
    66  //
    77  //   default constructor
    88  //
    99
     10  fBrightness  = 0.;
     11  fTimeRange   = TIMERANGE;
     12
     13  fFadcSlicesPerNanosec = fadc_slices_per_ns; // "real" number of FADC slices per ns
     14
     15  fResponseSlicesFadc = response_slices_fadc;
     16  // total number of bins in the histogram containing the response of the FADC to a
     17  // single photoelectron. The bins are narrower than the true FADC slices by a factor
     18  // equal to SUBBINS (see MFadcDefine.h)
     19
     20
     21  fBinsTrig = (Int_t)(TRIG_SLICES_PER_NSEC*TIMERANGE);   // Default value 4*10000=40000
     22  fTrigShape   = 0;
     23  fAmplTrig    = 0.;
     24  fFwhmTrig    = 0.;
     25
     26  fBinsFadc    = (Int_t)(fFadcSlicesPerNanosec*TIMERANGE);  // Default value 0.3*10000=3000
     27  fFadcShape   = 0;
     28  fIntegFadc   = 0.;
     29  fFwhmFadc    = 0.;
     30
     31
     32  fTrig     = new Float_t[fBinsTrig];
     33  fTrigResp = new Float_t[RESPONSE_SLICES_TRIG];
     34  fFadc     = new Float_t[fBinsFadc];
     35  fFadcResp = new Float_t[fResponseSlicesFadc];
     36 
     37  for (Int_t i= 0; i< fBinsTrig ; i++)
     38    fTrig[i] = 0. ;
     39
     40  for (Int_t i= 0; i < fBinsFadc; i++)
     41    fFadc[i] = 0.;
     42 
     43  for (Int_t i = 0; i < RESPONSE_SLICES_TRIG; i++)
     44    fTrigResp[i] = 0.;
     45
     46  for (Int_t i = 0; i < fResponseSlicesFadc; i++)
     47    fFadcResp[i] = 0.;
     48}
     49
     50void MStarLight::Reset() {
     51
     52 
    1053  fBrightness  = 0. ;
    11   fTimeRange   = TIMERANGE  ;
    12 
    13   fBinsTrig    = TRIGBINS   ;
    14   fTrigShape   = 0. ;
    15   fAmplTrig    = 0. ;
    16   fFwhmTrig    = 0. ;
    17 
    18   fBinsFadc    = FADCBINS   ;
    19   fFadcShape   = 0. ;
    20   fIntegFadc    = 0. ;
    21   fFwhmFadc    = 0. ;
    22 
    23  
    24   for (Int_t i= 0; i< TRIGBINS ; i++)
    25     fTrig[i] = 0. ;
    26 
    27   for (Int_t i= 0; i<FADCBINS; i++)
    28     fFadc[i] = 0. ;
    29  
    30   for (Int_t i= 0; i<40; i++)
    31     fTrigResp[i] = 0. ;
    32 
    33   for (Int_t i= 0; i<45; i++)
    34     fFadcResp[i] = 0. ;
    35 }
    36 
    37 void MStarLight::Reset() {
    38 
    39  
    40   fBrightness  = 0. ;
    41   fTimeRange   = TIMERANGE  ;
    42 
    43   fBinsTrig    = TRIGBINS   ;
    44   fTrigShape   = 0. ;
    45   fAmplTrig    = 0. ;
    46   fFwhmTrig    = 0. ;
    47 
    48   fBinsFadc    = FADCBINS   ;
    49   fFadcShape   = 0. ;
    50   fIntegFadc    = 0. ;
    51   fFwhmFadc    = 0. ;
    52 
    53  
    54   for (Int_t i= 0; i< TRIGBINS ; i++)
    55     fTrig[i] = 0. ;
    56 
    57   for (Int_t i= 0; i<FADCBINS; i++)
    58     fFadc[i] = 0. ;
    59  
    60   for (Int_t i= 0; i<40; i++)
    61     fTrigResp[i] = 0. ;
    62 
    63   for (Int_t i= 0; i<45; i++)
    64     fFadcResp[i] = 0. ;
    65 }
    66 
    67 
     54  fTimeRange   = TIMERANGE;
     55
     56  fTrigShape   = 0;
     57  fAmplTrig    = 0.;
     58  fFwhmTrig    = 0.;
     59
     60  fFadcShape   = 0;
     61  fIntegFadc   = 0.;
     62  fFwhmFadc    = 0.;
     63
     64 
     65  for (Int_t i= 0; i < fBinsTrig ; i++)
     66    fTrig[i] = 0.;
     67
     68  for (Int_t i= 0; i < fBinsFadc; i++)
     69    fFadc[i] = 0.;
     70 
     71  for (Int_t i = 0; i < RESPONSE_SLICES_TRIG; i++)
     72    fTrigResp[i] = 0.;
     73
     74  for (Int_t i = 0; i < fResponseSlicesFadc; i++)
     75    fFadcResp[i] = 0.;
     76}
    6877
    6978Float_t MStarLight::GetBrightness ()
    7079{
    71   return fBrightness  ;
     80  return fBrightness;
    7281}
    7382
    7483void MStarLight::SetBrightness (Float_t in )
    7584{
    76   fBrightness = in ;
     85  fBrightness = in;
    7786}
    7887
    7988Float_t MStarLight::GetAmplTrig ()
    8089{
    81   return fAmplTrig  ;
     90  return fAmplTrig ;
    8291}
    8392
    8493void MStarLight::SetAmplTrig (Float_t in )
    8594{
    86   fAmplTrig = in ;
     95  fAmplTrig = in;
    8796}
    8897
    8998Float_t  MStarLight::GetFwhmTrig ()
    9099{
    91   return fFwhmTrig  ;
     100  return fFwhmTrig;
    92101}
    93102
    94103void MStarLight::SetFwhmTrig (Float_t in )
    95104{
    96   fFwhmTrig = in ;
    97 }
    98 
     105  fFwhmTrig = in;
     106}
     107
     108void MStarLight::SetFadcSlicesPerNanosec (Float_t in)
     109{
     110  fFadcSlicesPerNanosec = in;
     111  fBinsFadc    = (Int_t)(fFadcSlicesPerNanosec*TIMERANGE);
     112
     113  if (fFadc)
     114    delete [] fFadc;
     115
     116  fFadc = new Float_t[fBinsFadc];
     117
     118  for (Int_t i= 0; i < fBinsFadc; i++)
     119    fFadc[i] = 0.; 
     120}
    99121
    100122Float_t MStarLight::GetIntegFadc ()
    101123{
    102   return fIntegFadc  ;
     124  return fIntegFadc;
    103125}
    104126
    105127void MStarLight::SetIntegFadc (Float_t in )
    106128{
    107   fIntegFadc = in ;
     129  fIntegFadc = in;
    108130}
    109131
    110132Float_t  MStarLight::GetFwhmFadc ()
    111133{
    112   return fFwhmFadc  ;
     134  return fFwhmFadc;
    113135}
    114136
    115137void MStarLight::SetFwhmFadc (Float_t in )
    116138{
    117   fFwhmFadc = in ;
    118 }
    119 
    120 
    121 void MStarLight::SetTrigResponse( Float_t *in ) {
    122  
    123   for (Int_t i= 0; i<40; i++)
    124     fTrigResp[i] = in[i] ;
    125  
    126 }
    127 
    128 void MStarLight::SetFadcResponse( Float_t *in ) {
    129 
    130   for (Int_t i= 0; i<45; i++)
    131     fFadcResp[i] = in[i] ;
    132 }
    133 
    134 void MStarLight::FillResponse( Float_t ampl, Float_t time ) {
    135 
    136   //     fill the trigger response
    137  
    138   Int_t startbin = (Int_t) (time * 4)  ;
    139  
    140   Int_t icount = 0 ;
    141   Int_t idata      ;
    142  
    143   for ( Int_t i=startbin ; i<startbin+40 ; i++) {
    144     //
    145     if ( i < TRIGBINS )
    146       idata = i ;
    147     else if ( i >= TRIGBINS )
    148       idata = i - TRIGBINS ;
    149 
    150     fTrig[idata] = fTrig[idata] + ampl * fTrigResp[icount] ;
    151    
    152     icount++ ;
    153   }
     139  fFwhmFadc = in;
     140}
     141
     142
     143void MStarLight::SetTrigResponse( Float_t *in )
     144{
     145  for (Int_t i = 0; i < RESPONSE_SLICES_TRIG; i++)
     146    fTrigResp[i] = in[i];
     147}
     148
     149void MStarLight::SetFadcResponse( Float_t *in )
     150{
     151  for (Int_t i = 0; i < fResponseSlicesFadc; i++)
     152    fFadcResp[i] = in[i];
     153}
     154
     155void MStarLight::FillResponse( Float_t ampl, Float_t time )
     156{
     157  //  fill the trigger response
     158 
     159  Int_t startbin = (Int_t) (time * ((Float_t)fBinsTrig/TIMERANGE));
     160
     161  Int_t icount = 0;
     162  Int_t idata;
     163 
     164  for ( Int_t i = startbin ; i < startbin+RESPONSE_SLICES_TRIG ; i++)
     165    {
     166      if ( i < fBinsTrig )
     167        idata = i;
     168      else if ( i >= fBinsTrig )
     169        idata = i - fBinsTrig;
     170
     171      fTrig[idata] = fTrig[idata] + ampl * fTrigResp[icount];
     172      icount++ ;
     173    }
    154174
    155175  //
    … …  
    157177  //
    158178
    159   startbin = (Int_t) ( time / 0.6666666666 );
    160  
     179  startbin = (Int_t) ( time * ((Float_t)(fBinsFadc*SUBBINS)/TIMERANGE));
     180
    161181  Int_t ichanfadc = 0 ;
    162182 
    163183  //
    164184  //   putting the response slices in the right sig slices.
    165   //   Be carefull, because both slices have different widths.
     185  //   Be careful, because both slices have different widths.
    166186  //
    167187
    … …  
    170190  // the signal within each FADC slice, but measures just the signal height
    171191  // at one point, like the real FADC does. By default, each FADC slice
    172   // contains 5 bins of the response histogram(fFadcResp[45]). Warning:
    173   // do not change this unless you do the corresponding modifications also
    174   // in MFadc.cxx, or the signal and the noise photoelectrons will be treated
    175   // differently!!
    176   //
    177 
    178   for ( Int_t i = 0 ; i < 45; i += 5 ) {
    179     ichanfadc = (Int_t) ((startbin+i)/5) ;
    180    
    181     if ( (ichanfadc) < FADCBINS )
    182       idata = ichanfadc ;
    183     else if ( ichanfadc >=FADCBINS )
    184       idata = ichanfadc-FADCBINS ;
    185    
    186     fFadc[idata] += (ampl * fFadcResp[i] )  ;
    187    
    188   }
    189 
     192  // contains SUBBINS bins of the response histogram
     193  // (fFadcResp). Warning: do not change this unless you do the corresponding
     194  // modifications also in MFadc.cxx, or the signal and the noise photoelectrons
     195  // will be treated differently!!
     196  //
     197
     198  for ( Int_t i = 0 ; i < fResponseSlicesFadc; i += SUBBINS )
     199    {
     200      ichanfadc = (Int_t) ((startbin+i)/(Float_t)SUBBINS);
     201
     202      if ( ichanfadc < fBinsFadc )
     203        idata = ichanfadc;
     204      else if ( ichanfadc >= fBinsFadc )
     205        idata = ichanfadc-fBinsFadc;
     206
     207      fFadc[idata] += (ampl * fFadcResp[i]);
     208    }
    190209}
    191210
    … …  
    197216  TRandom2 wuerfel( (UInt_t) (noiseTrig*100) ) ;
    198217 
    199   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    200     fTrig[i] += wuerfel.Gaus(0., noiseTrig ) ;
    201   }
    202 
    203   for (Int_t i=0; i< FADCBINS ; i++ ) {
    204     fFadc[i] += wuerfel.Gaus(0., noiseFadc ) ;
    205   }
    206  
    207  
    208 }
    209 
    210 Float_t MStarLight::GetTrig( Int_t i){
     218  for (Int_t i=0; i< fBinsTrig ; i++ )
     219    fTrig[i] += wuerfel.Gaus(0., noiseTrig );
     220
     221  for (Int_t i=0; i< fBinsFadc ; i++ )
     222    fFadc[i] += wuerfel.Gaus(0., noiseFadc );
     223 
     224}
     225
     226Float_t MStarLight::GetTrig( Int_t i)
     227{
    211228  //------------------------------------------------------------------
    212229  //
    213   //  It gets the value of the simualted trigger in the i bin
     230  //  It gets the value of the simulated trigger in the i bin
    214231  //
    215232  return fTrig[i];
    216233}
    217234
    218 Float_t MStarLight::GetFadc( Int_t i){
     235Float_t MStarLight::GetFadc( Int_t i)
     236{
    219237  //------------------------------------------------------------------
    220238  //
    221   //  It gets the value of the simualted FADC signal in the i bin
     239  //  It gets the value of the simulated FADC signal in the i bin
    222240  //
    223241  return fFadc[i];
    224242}
    225243
    226 void MStarLight::StoreHisto( char *filename) {
    227  
    228   Float_t baseline = 0. ;
    229 
    230 
    231   //    first the histogramms for trigger
     244void MStarLight::StoreHisto( char *filename)
     245{
     246
     247  Float_t baseline = 0.;
     248
     249  //    first the histograms for trigger
    232250  //
    233251  //    the calculated trigger signal before baseline
    234252  //
    235253
    236   TH1F  trigresp ("trigresp", "Trigger Response", TRIGBINS, 0., TIMERANGE) ;
    237 
    238   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    239    
    240     trigresp.SetBinContent(i, fTrig[i]) ;
    241 
    242     baseline = baseline + fTrig[i]  ;
    243   }
    244 
    245   baseline = baseline / TRIGBINS ;
     254  TH1F  trigresp ("trigresp", "Trigger Response", fBinsTrig, 0., TIMERANGE);
     255
     256  for (Int_t i=0; i< fBinsTrig ; i++ )
     257    {
     258      trigresp.SetBinContent(i+1, fTrig[i]);
     259      baseline += fTrig[i];
     260    }
     261
     262  baseline /= fBinsTrig;
    246263 
    247264  TH1F  trigbase ("trigbase", "Response after Baseline shift",
    248                   TRIGBINS, 0., TIMERANGE) ;
    249   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    250    
    251     trigbase.SetBinContent(i, fTrig[i]-baseline ) ;
    252    
    253   }
     265                  fBinsTrig, 0., TIMERANGE) ;
     266
     267  for (Int_t i = 0; i < fBinsTrig ; i++)
     268    trigbase.SetBinContent(i+1, fTrig[i]-baseline );
    254269 
    255270  TH1F  trigdist ("trigdist", "Noise on the baseline",
    256                   1000, -25., 25. ) ;
    257 
    258   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    259    
    260     trigdist.Fill( (Float_t) trigbase.GetBinContent(i) ) ;
    261   }
     271                  1000, -25., 25. );
     272
     273  for (Int_t i = 0; i < fBinsTrig ; i++)
     274    trigdist.Fill( (Float_t) trigbase.GetBinContent(i+1) );
    262275
    263276
    264277  //
    265   //     second the histograms for the fadc
    266   //
    267  
    268  
    269   TH1F  fadcresp ("fadcresp", "Fadc Response", FADCBINS, 0., TIMERANGE) ;
    270 
    271   for (Int_t i=0; i< FADCBINS ; i++ ) {
    272    
    273     fadcresp.SetBinContent(i, fFadc[i]) ;
    274 
    275     baseline = baseline + fFadc[i]  ;
    276   }
    277 
    278   baseline = baseline / FADCBINS ;
     278  // Now the histograms for the fadc
     279  //
     280
     281  TH1F  fadcresp ("fadcresp", "Fadc Response", fBinsFadc, 0., TIMERANGE);
     282
     283  baseline = 0.;
     284  for (Int_t i=0; i < fBinsFadc; i++)
     285    {
     286      fadcresp.SetBinContent(i+1, fFadc[i]);
     287      baseline += fFadc[i];
     288    }
     289
     290  baseline /= fBinsFadc;
    279291 
    280292  TH1F  fadcbase ("fadcbase", "Fadc after Baseline shift",
    281                   FADCBINS, 0., TIMERANGE) ;
    282   for (Int_t i=0; i< FADCBINS ; i++ ) {
    283    
    284     fadcbase.SetBinContent(i, fFadc[i]-baseline ) ;
    285    
    286   }
    287  
     293                  fBinsFadc, 0., TIMERANGE) ;
     294
     295  for (Int_t i=0; i< fBinsFadc ; i++ )
     296    fadcbase.SetBinContent(i+1, fFadc[i]-baseline );
     297
    288298  TH1F  fadcdist ("fadcdist", "Noise on fadc",
    289299                  1000, -100., 100. ) ;
    290300
    291   for (Int_t i=0; i< FADCBINS ; i++ ) {
    292    
    293     fadcdist.Fill( (Float_t) fadcbase.GetBinContent(i) ) ;
    294   }
    295 
    296 
    297 
    298  
    299   TFile outfile( filename, "UPDATE" ) ;
    300  
    301   trigresp.Write() ;
    302   trigbase.Write() ;
    303   trigdist.Write() ;
    304 
    305   fadcresp.Write() ;
    306   fadcbase.Write() ;
    307   fadcdist.Write() ;
    308  
    309  
    310   outfile.Close() ;
    311 }
    312 
    313 void MStarLight::WriteBinary( char *filename) {
    314   //
    315   //  write the things to the binary file
     301  for (Int_t i=0; i< fBinsFadc ; i++ )
     302    fadcdist.Fill( (Float_t) fadcbase.GetBinContent(i+1) );
     303
     304  TFile outfile( filename, "RECREATE");
     305 
     306  trigresp.Write();
     307  trigbase.Write();
     308  trigdist.Write();
     309
     310  fadcresp.Write();
     311  fadcbase.Write();
     312  fadcdist.Write();
     313 
     314 
     315  outfile.Close();
     316}
     317
     318void MStarLight::WriteBinary( char *filename)
     319{
     320  //
     321  //  write the information to the binary file
    316322
    317323  FILE *datei ;
    … …  
    319325  datei = fopen ( filename, "w" ) ;
    320326 
    321   if ( ! datei ) {
    322     cout << " ERROR: Can't open the file " << filename
    323          << endl ;
    324     exit (230) ;
    325   }
     327  if ( ! datei )
     328    {
     329      cout << " ERROR: Can't open the file " << filename << endl;
     330      exit (230);
     331    }
    326332
    327333  Float_t version = VERSIONSR;
    … …  
    329335  //   write them out
    330336
    331   fwrite ( &version, sizeof(Float_t), 1, datei ) ;
    332   fwrite ( &fBrightness, sizeof(Float_t), 1, datei ) ;
    333   fwrite ( &fTimeRange , sizeof(Float_t), 1, datei ) ;
    334 
    335   fwrite ( &fBinsTrig  , sizeof(Float_t), 1, datei ) ;
    336   fwrite ( &fTrigShape , sizeof(Float_t), 1, datei ) ;
    337   fwrite ( &fAmplTrig  , sizeof(Float_t), 1, datei ) ;
    338   fwrite ( &fFwhmTrig  , sizeof(Float_t), 1, datei ) ;
    339 
    340   fwrite ( &fBinsFadc  , sizeof(Float_t), 1, datei ) ;
    341   fwrite ( &fFadcShape , sizeof(Float_t), 1, datei ) ;
    342   fwrite ( &fIntegFadc , sizeof(Float_t), 1, datei ) ;
    343   fwrite ( &fFwhmFadc  , sizeof(Float_t), 1, datei ) ;
    344 
    345   fwrite ( &fTrig      , sizeof(Float_t), TRIGBINS, datei ) ;
     337  fwrite ( &version,               sizeof(Float_t), 1, datei );
     338  fwrite ( &fBrightness,           sizeof(Float_t), 1, datei );
     339  fwrite ( &fTimeRange,            sizeof(Float_t), 1, datei );
     340  fwrite ( &fFadcSlicesPerNanosec, sizeof(Float_t), 1, datei );
     341
     342  fwrite ( &fBinsTrig  , sizeof(Int_t),   1, datei );
     343  fwrite ( &fTrigShape , sizeof(Int_t),   1, datei );
     344  fwrite ( &fAmplTrig  , sizeof(Float_t), 1, datei );
     345  fwrite ( &fFwhmTrig  , sizeof(Float_t), 1, datei );
     346
     347  fwrite ( &fBinsFadc  , sizeof(Int_t),   1, datei );
     348  fwrite ( &fFadcShape , sizeof(Int_t),   1, datei );
     349  fwrite ( &fIntegFadc , sizeof(Float_t), 1, datei );
     350  fwrite ( &fFwhmFadc  , sizeof(Float_t), 1, datei );
     351
     352  fwrite (fTrig, sizeof(Float_t), fBinsTrig, datei);
    346353
    347354  //    We want to store the FADC signal taking into account the AC
    … …  
    351358  //
    352359
    353   Float_t baseline = 0. ;
    354 
    355   for (Int_t i=0; i< FADCBINS ; i++ ) {
    356    
    357     baseline = baseline + fFadc[i]  ;
    358   }
    359 
    360   baseline = baseline / FADCBINS ;
    361  
    362   for (Int_t i=0; i< FADCBINS ; i++ ) {
    363    
    364       fFadc[i]=fFadc[i]-baseline;
    365    
    366   }
    367  
    368   fwrite ( &fFadc      , sizeof(Float_t), FADCBINS, datei ) ;
    369 
    370 
    371   fclose ( datei ) ;
     360  Float_t baseline = 0.;
     361
     362  for (Int_t i=0; i< fBinsFadc ; i++ )
     363    baseline += fFadc[i];
     364
     365  baseline /= fBinsFadc;
     366
     367  Float_t *temp = new Float_t[fBinsFadc];
     368
     369  for (Int_t i=0; i < fBinsFadc; i++ )
     370    temp[i] = fFadc[i]-baseline;
     371 
     372  fwrite (temp, sizeof(Float_t), fBinsFadc, datei);
     373
     374  delete [] temp;
     375
     376  fclose ( datei );
    372377 
    373378}
    … …  
    393398
    394399  Float_t read_version;
    395   Float_t current_version=VERSIONSR;
    396 
    397   // Check taht we read the right version of the Database
     400  Float_t current_version = VERSIONSR;
     401
     402  // Check that we read the right version of the Database
    398403  fread ( &read_version, sizeof(Float_t), 1, datei ) ;
    399404
    400405  if(Int_t(read_version)!=Int_t(current_version)){
    401406    cout<<" ERROR: You are trying to read database VERSION "<<
    402       read_version<<endl;
     407      read_version << endl;
    403408    cout<<"        You must generate a database for the current VERSION "<<
    404       current_version<<endl;
     409      current_version << endl;
    405410    cout<<"        See the NSB database section in the Camera How to Use note."
    406411        <<endl;
    … …  
    408413  }
    409414
    410   fread ( &fBrightness, sizeof(Float_t), 1, datei ) ;
    411   fread ( &fTimeRange , sizeof(Float_t), 1, datei ) ;
    412 
    413 
    414   fread ( &fBinsTrig  , sizeof(Float_t), 1, datei ) ;
    415   fread ( &fTrigShape , sizeof(Float_t), 1, datei ) ;
    416   fread ( &fAmplTrig  , sizeof(Float_t), 1, datei ) ;
    417   fread ( &fFwhmTrig  , sizeof(Float_t), 1, datei ) ;
    418 
    419   fread ( &fBinsFadc  , sizeof(Float_t), 1, datei ) ;
    420   fread ( &fFadcShape , sizeof(Float_t), 1, datei ) ;
    421   fread ( &fIntegFadc , sizeof(Float_t), 1, datei ) ;
    422   fread ( &fFwhmFadc  , sizeof(Float_t), 1, datei ) ;
    423 
    424   fread ( &fTrig      , sizeof(Float_t), TRIGBINS, datei ) ;
    425 
    426   fread ( &fFadc      , sizeof(Float_t), FADCBINS, datei ) ;
    427 
    428  
     415  fread ( &fBrightness, sizeof(Float_t), 1, datei );
     416  fread ( &fTimeRange , sizeof(Float_t), 1, datei );
     417  fread ( &fFadcSlicesPerNanosec, sizeof(Float_t), 1, datei );
     418
     419  fread ( &fBinsTrig  , sizeof(Int_t),   1, datei );
     420  fread ( &fTrigShape , sizeof(Int_t),   1, datei );
     421  fread ( &fAmplTrig  , sizeof(Float_t), 1, datei );
     422  fread ( &fFwhmTrig  , sizeof(Float_t), 1, datei );
     423
     424  fread ( &fBinsFadc  , sizeof(Int_t),   1, datei );
     425  fread ( &fFadcShape , sizeof(Int_t),   1, datei );
     426  fread ( &fIntegFadc , sizeof(Float_t), 1, datei );
     427  fread ( &fFwhmFadc  , sizeof(Float_t), 1, datei );
     428
     429  if (fTrig)
     430    delete [] fTrig;
     431
     432  if (fFadc)
     433    delete [] fFadc;
     434
     435  fTrig = new Float_t[fBinsTrig];
     436  fFadc = new Float_t[fBinsFadc];
     437
     438  fread (fTrig, sizeof(Float_t), fBinsTrig, datei);
     439  fread (fFadc, sizeof(Float_t), fBinsFadc, datei);
    429440
    430441  fclose ( datei ) ;
    431442}
    432 
    433 
    434 
    435 

  • trunk/MagicSoft/Simulation/Detector/StarResponse/MStarLight.hxx

    r5099 r5248  
     1#include "MFadcDefine.h"
     2#include "MTriggerDefine.h"
     3
    14#ifndef __MStarLight__
    25#define __MStarLight__
    … …  
    1316#include "TRandom2.h"
    1417
    15 #define VERSIONSR   1002.0
    16 #define TIMERANGE   10000.
    17 #define TRIGBINS    40000
    18 #define FADCBINS     3000
     18#define VERSIONSR   1003.0
     19#define TIMERANGE   10000  // ns
    1920
    2021class MStarLight {
    … …  
    2223 private:
    2324 
    24   Float_t  fBrightness  ;   // the brightness of the star in phe/nsec
     25  Float_t  fBrightness;  // the brightness of the star in phe/nsec
    2526 
    26   Float_t  fTimeRange   ;   // the time range of the trigger response
     27  Float_t  fTimeRange;   // the time range of the trigger response
    2728 
    28   Float_t  fBinsTrig    ;   // Number of Bins in the trigger
    29   Float_t  fTrigShape   ;   // a number that indicate the shape type of
    30                             // the signal   
    31                             // = 0 --> a gaussian 
    32   Float_t  fAmplTrig    ;   // the amplitude of the trigger in mV
    33   Float_t  fFwhmTrig    ;   // the width of the signal in nsec
     29  Int_t    fBinsTrig;    // Number of Bins in the trigger database
     30  Int_t    fTrigShape;   // a number that indicate the shape type of
     31                         // the signal   
     32                         // = 0 --> a gaussian 
     33  Float_t  fAmplTrig;    // the amplitude of the trigger in mV
     34  Float_t  fFwhmTrig;    // the width of the signal in nsec
    3435
    35   Float_t  fBinsFadc    ;   // Number of Bins in the trigger
    36   Float_t  fFadcShape   ;   // a number that indicate the shape type of
    37                             // the signal   
    38                             // = 0 --> a gaussian 
    39   Float_t  fIntegFadc    ;  // the integral of the single phe response
    40                             // in the FADC (in FADC counts)
    41   Float_t  fFwhmFadc    ;   // the width of the signal in nsec
     36  Int_t    fBinsFadc;    // Number of Bins in the FADC database
     37  Int_t    fFadcShape;   // a number that indicate the shape type of
     38                         // the signal   
     39                         // = 0 --> a gaussian 
     40  Float_t  fIntegFadc;   // the integral of the single phe response
     41                         // in the FADC (in FADC counts)
     42  Float_t  fFwhmFadc;    // the width of the signal in nsec
    4243 
    43   Float_t  fTrig[TRIGBINS] ;   // 4.0 bins per nsec for 10000 nanoseconds
    44   Float_t  fFadc[FADCBINS]  ;   // 0.3 bins per nsec for 10000 nanoseconds
    45  
    46   Float_t  fTrigResp [ 40 ] ;   // the shape of the response for trigger
    47   Float_t  fFadcResp [ 45 ] ;   // the shape of the response for FADC
     44  Float_t  *fTrig;       // Trigger branch "history" for 10000 nanoseconds
     45  Float_t  *fTrigResp;   // the shape of the response for trigger
     46  Float_t  *fFadc;       // FADC "history" for 10000 nanoseconds
     47  Float_t  *fFadcResp;   // the shape of the response for FADC
     48
     49  Float_t  fFadcSlicesPerNanosec; // Number of FADC slices per ns
     50                                  // (may be < 1 if FADC is faster than 1 GHz)
     51
     52  Int_t    fResponseSlicesFadc;
    4853
    4954 public:
    50  
    51   MStarLight() ;
    5255
    53   void Reset() ;
     56  MStarLight(Float_t fadc_slices_per_ns = 0.,
     57             Int_t response_slices_fadc = 0);
    5458
    55   void SetBrightness( Float_t in ) ;
    56   void SetAmplTrig( Float_t in ) ;
    57   void SetFwhmTrig( Float_t in ) ;
    58   void SetShapeFadc( Float_t in ) { fFadcShape=in;}
    59   void SetIntegFadc( Float_t in ) ;
    60   void SetFwhmFadc( Float_t in ) ;
     59  void Reset();
    6160
    62   Float_t GetBrightness() ;
    63   Float_t GetAmplTrig() ;
    64   Float_t GetFwhmTrig() ;
    65   Float_t GetShapeFadc() {return fFadcShape;}
    66   Float_t GetIntegFadc() ;
    67   Float_t GetFwhmFadc() ;
     61  void SetBrightness(Float_t in);
     62  void SetAmplTrig(Float_t in);
     63  void SetFwhmTrig(Float_t in);
     64  void SetShapeFadc(Int_t in)              {fFadcShape=in;}
     65  void SetIntegFadc(Float_t in);
     66  void SetFwhmFadc(Float_t in);
     67  void SetFadcSlicesPerNanosec(Float_t in);
    6868
    69   void SetTrigResponse(Float_t *in) ;
    7069
    71   void SetFadcResponse(Float_t *in) ;
     70  Float_t GetBrightness();
     71  Float_t GetAmplTrig();
     72  Float_t GetFwhmTrig();
     73  Int_t   GetShapeFadc()            {return fFadcShape;}
     74  Float_t GetIntegFadc();
     75  Float_t GetFwhmFadc();
     76  Int_t   GetBinsTrig()             {return fBinsTrig;}
     77  Int_t   GetBinsFadc()             {return fBinsFadc;}
     78  Float_t GetTimeRange()            {return fTimeRange;}
     79  Float_t GetFadcSlicesPerNanosec() {return fFadcSlicesPerNanosec;}
    7280
    73   void FillResponse(Float_t ampl, Float_t time) ;
     81  void SetTrigResponse(Float_t *in);
     82  void SetFadcResponse(Float_t *in);
    7483
    75   void ElecNoise ( Float_t noiseTrig =  0.3 , Float_t noiseFadc = .5 ) ;
     84  void FillResponse(Float_t ampl, Float_t time);
     85
     86  void ElecNoise ( Float_t noiseTrig =  0.3 , Float_t noiseFadc = .5 );
    7687
    7788  Float_t GetTrig (Int_t i);
    78 
    7989  Float_t GetFadc (Int_t i);
    8090
    81   void StoreHisto  (char *filename ) ;
     91  Float_t* GetTrigPointer (Int_t i) { return &(fTrig[i]); }
     92  Float_t* GetFadcPointer (Int_t i) { return &(fFadc[i]); }
    8293
    83   void WriteBinary (char *filename ) ;
     94  void StoreHisto  (char *filename );
    8495
    85   void ReadBinary (char *filename ) ;
     96  void WriteBinary (char *filename );
    8697
    87 } ;
     98  void ReadBinary (char *filename );
     99
     100};
    88101
    89102#endif

  • trunk/MagicSoft/Simulation/Detector/StarResponse/srreadparam.cxx

    r5099 r5248  
    1919//=
    2020//= $RCSfile: srreadparam.cxx,v $
    21 //= $Revision: 1.5 $
     21//= $Revision: 1.6 $
    2222//= $Author: moralejo $
    23 //= $Date: 2004-09-17 13:51:02 $
     23//= $Date: 2004-10-12 13:41:09 $
    2424//=
    2525//=//////////////////////////////////////////////////////////////////////
    … …  
    7575static float Simulated_Phe_p = 0.1;          //@< precision for phe loop
    7676static int   FADC_Shape=0;
    77 static float FADC_Integ=MFADC_RESPONSE_INTEGRAL;
    78 static float FADC_FWHM=MFADC_RESPONSE_FWHM;
    79 static int   Trig_Shape=0;
    80 static float Trig_Ampl=1.0;
    81 static float Trig_FWHM=2.0;
    82 static int   Write_Root=0;
     77static float FADC_Integ = MFADC_RESPONSE_INTEGRAL;
     78static float FADC_FWHM = MFADC_RESPONSE_FWHM;
     79static float FADC_slices_per_ns = FADC_SLICES_PER_NSEC;
     80static int   Trig_Shape = 0;
     81static float Trig_Ampl = 1.0;
     82static float Trig_FWHM = 2.0;
     83static int   Write_Root = 0;
    8384//!@}
    8485
    … …  
    169170      break;
    170171
     172    case fadc_GHz:  //  Get FADC sampling frequency in GHz
     173
     174      sscanf(line, "%s %f", token, &FADC_slices_per_ns);
     175
     176      break;
     177
    171178    case write_root:          //@< Write histogram
    172179
    … …  
    273280//!@{
    274281void
    275 get_fadc_properties(int *shape, float *integ, float *fwhm)
     282get_fadc_properties(int *shape, float *integ, float *fwhm, float *fadc_spns)
    276283{
    277284  *shape =  FADC_Shape;
    278285  *integ =  FADC_Integ;
    279   *fwhm =  FADC_FWHM;
     286  *fwhm  =  FADC_FWHM;
     287  *fadc_spns = FADC_slices_per_ns;
    280288}
    281289//!@}
    … …  
    306314//
    307315// $Log: not supported by cvs2svn $
     316// Revision 1.5  2004/09/17 13:51:02  moralejo
     317//
     318// Adapted headers to current c++ style, removed -Wno-deprecated from
     319// compilation options.
     320//
    308321// Revision 1.4  2004/09/16 16:20:13  moralejo
    309322// *** empty log message ***

  • trunk/MagicSoft/Simulation/Detector/StarResponse/srreadparam.h

    r5099 r5248  
    1919//=
    2020//= $RCSfile: srreadparam.h,v $
    21 //= $Revision: 1.4 $
     21//= $Revision: 1.5 $
    2222//= $Author: moralejo $
    23 //= $Date: 2004-09-17 13:51:02 $
     23//= $Date: 2004-10-12 13:41:09 $
    2424//=
    2525//=//////////////////////////////////////////////////////////////////////
    … …  
    9191T(trig_properties), /* shape for the single phe trigger response */  \
    9292T(fadc_properties), /* shape for the single phe fadc response */ \
     93T(fadc_GHz),        /* FADC sampling frequency in GHz */ \
    9394T(write_root),      /* write root file with some histograms */ \
    9495T(end_file)         /* end of the parameters file */
    … …  
    128129void get_simulated_phe(float *lphe, float *uphe, float *pphe);
    129130void get_trig_properties(int *shape, float *ampl, float *fwhm);
    130 void get_fadc_properties(int *shape, float *ampl, float *fwhm);
     131void get_fadc_properties(int *shape, float *ampl, float *fwhm, float *slicesperns);
    131132int get_write_root();
    132133//!@}
    … …  
    145146/*
    146147 * $Log: not supported by cvs2svn $
     148 * Revision 1.4  2004/09/17 13:51:02  moralejo
     149 *
     150 * Adapted headers to current c++ style, removed -Wno-deprecated from
     151 * compilation options.
     152 *
    147153 * Revision 1.3  2004/09/16 16:20:13  moralejo
    148154 * *** empty log message ***

  • trunk/MagicSoft/Simulation/Detector/StarResponse/starresponse.cxx

    r5099 r5248  
    2323  TRandom2 Zufall( (UInt_t) brightness * 100)  ;      // a random generator
    2424
    25   MStarLight  data  ;    // create  instance of the MStarLight
     25  MStarLight  data(fadc->GetFadcSlicesPerNanosec(), fadc->GetResponseSlicesFadc());
     26  // create  instance of the MStarLight
    2627
    2728  //  Shall I write the root file???
    … …  
    3132  write_root= get_write_root();
    3233 
     34  Float_t   trigresp[RESPONSE_SLICES_TRIG];
     35
    3336  //  Get information from Trigger instance!!!
    34    
    35   cout << sizeof (trigger) << endl ;
     37  trigger->GetResponse(trigresp);
     38  data.SetTrigResponse(trigresp);
     39 
     40  data.SetAmplTrig ( trigger->GetAmplitude() );
     41  data.SetFwhmTrig ( trigger->GetFwhm() );
     42 
     43  Float_t  *fadcresp = new Float_t[fadc->GetResponseSlicesFadc()];
    3644
    37   Float_t   trigresp[40] ;
    38   trigger->GetResponse ( trigresp ) ;
    39   data.SetTrigResponse( trigresp ) ;
    40  
    41   data.SetAmplTrig ( trigger->GetAmplitude() ) ;
    42   data.SetFwhmTrig ( trigger->GetFwhm() ) ;
    43  
    4445  //  Get information from FADC instance !!!!!
     46  fadc->GetResponse(fadcresp);
     47  data.SetFadcResponse(fadcresp);
    4548
    46   Float_t   fadcresp[45] ;
    47   fadc->GetResponse (fadcresp ) ;   
    48   data.SetFadcResponse( fadcresp ) ;
    49 
    50   data.SetShapeFadc ( fadc->GetShape() ) ;
    51   data.SetIntegFadc ( fadc->GetIntegral() ) ;
    52   data.SetFwhmFadc ( fadc->GetFwhm() ) ;
     49  data.SetShapeFadc ( fadc->GetShape() );
     50  data.SetIntegFadc ( fadc->GetIntegral() );
     51  data.SetFwhmFadc ( fadc->GetFwhm() );
    5352 
    5453  //  start with the loop over random events
    5554  //
    5655 
    57   Float_t a     = 0. ;   // the amplitude of the signal
    58   Float_t time  = 0. ;   // the time of the phe
     56  Float_t a     = 0.;   // the amplitude of the signal
     57  Float_t time  = 0.;   // the time of the phe
    5958
    60   for (Int_t i = 0 ; i< (Int_t ) (brightness * TIMERANGE) ; i++) {
    61    
    62     a = trigger->FillStar( 500, 10.) ;   // random the amplitude
    63     time=Zufall.Rndm() * TIMERANGE ;     // random the time
     59  for (Int_t i = 0; i < (Int_t) (brightness * TIMERANGE) ; i++)
     60    {
     61      a = trigger->FillStar( 500, 10.) ;   // random the amplitude
     62      time=Zufall.Rndm() * TIMERANGE ;     // random the time
    6463
    65     data.FillResponse(a, time ) ;        // fill the response function
    66    
    67   }
     64      data.FillResponse(a, time ) ;        // fill the response function     
     65    }
    6866
    6967  if(brightness<=1.0)
    … …  
    7169  else
    7270    sprintf(filename, "%sBrightness%.1f.slt", path, brightness) ;
    73   data.WriteBinary( filename ) ;
    7471
    75   data.Reset() ;
     72  data.WriteBinary( filename );
    7673
    77   if(write_root){
    78     data.ReadBinary( filename ) ;
    79    
    80     if(brightness<1.0)
    81       sprintf(filename, "%sBrightness%.2f.root", path, brightness) ;
    82     else
    83       sprintf(filename, "%sBrightness%.1f.root", path, brightness) ;
    84     sprintf(filename, "%sBrightness%.2f.root", path, brightness) ;
    85     cout << " the file will be written in " << filename
    86          << endl ;
     74  if(write_root)
     75    {
     76      if(brightness<=1.0)
     77        sprintf(filename, "%sBrightness%.2f.root", path, brightness);
     78      else
     79        sprintf(filename, "%sBrightness%.1f.root", path, brightness);
    8780
    88     data.StoreHisto( filename ) ;
    89   }
     81      cout << " the file will be written in " << filename << endl;
    9082
    91   return  (0) ;
     83      data.StoreHisto( filename );
     84    }
     85
     86  data.Reset();
     87
     88  return(0);
    9289
    9390}
    … …  
    112109  float trig_fwhm,trig_ampl;
    113110  float fadc_fwhm,fadc_integral;
    114   int fadc_shape, trig_shape;
     111  float fadc_slices_per_ns;
     112  Int_t fadc_shape, trig_shape;
    115113
    116114  //
    … …  
    120118
    121119  //  Instance of MFadc and MTrigger needed inside BuildStarLight
    122   MTrigger *trigger;//= new MTrigger(1);
    123   MFadc *fadc;//= new MFadc;
     120
     121  MTrigger *trigger;
     122  MFadc *fadc;
    124123
    125124  if(argc == 1){
    … …  
    142141  trigger = new MTrigger(1,0.,0.,trig_ampl,trig_fwhm);
    143142
    144   get_fadc_properties(&fadc_shape, &fadc_integral, &fadc_fwhm);
    145   fadc = new MFadc(1,fadc_shape,fadc_integral,fadc_fwhm,fadc_shape,fadc_integral,fadc_fwhm);
     143  get_fadc_properties(&fadc_shape, &fadc_integral, &fadc_fwhm, &fadc_slices_per_ns);
    146144
    147   for (Float_t b=nphe_min; b<=nphe_max; b=b+nphe_pre )  //  loop over Brightness
    148     {
    149       BuildStarLight (b, path, trigger, fadc ) ; 
    150     }
     145  fadc = new MFadc(1, fadc_shape, fadc_integral, fadc_fwhm,
     146                   fadc_shape, fadc_integral, fadc_fwhm, 0., fadc_slices_per_ns);
     147
     148  // loop over Brightness
     149
     150  // Limit precision (for speed reasons). Below 1 phe/ns/pixel we build the database
     151  // files in steps of 0.01 (minimum). Above 1 phe/ns/pixel the steps are of 0.1 at least.
     152  // These values can be made larger through the input card of starresponse
     153
     154  nphe_pre = nphe_pre < 0.01? 0.01 : nphe_pre;
     155  for (Float_t b = nphe_min; b <= 1.0; b += nphe_pre )
     156    BuildStarLight (b, path, trigger, fadc); 
     157
     158  nphe_pre = nphe_pre < 0.1? 0.1 : nphe_pre;
     159  for (Float_t b = 1.0+nphe_pre; b <= nphe_max; b += nphe_pre )
     160    BuildStarLight (b, path, trigger, fadc); 
     161
    151162  delete(trigger);
    152163  delete(fadc);
Note: See TracChangeset for help on using the changeset viewer.