Changeset 5248


Ignore:
Timestamp:
10/12/04 14:43:18 (20 years ago)
Author:
moralejo
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Simulation/Detector
Files:
11 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);
  • trunk/MagicSoft/Simulation/Detector/include-MFadc/MFadc.cxx

    r5099 r5248  
    2020using namespace std;
    2121
    22 MFadc::MFadc(Int_t pix, Int_t shape, Float_t integral, Float_t fwhm, Int_t shapeout, Float_t integralout, Float_t fwhmout, Float_t trigger_delay) {
     22MFadc::MFadc(Int_t pix, Int_t shape, Float_t integral, Float_t fwhm,
     23             Int_t shapeout, Float_t integralout, Float_t fwhmout,
     24             Float_t trigger_delay, Float_t fadc_slices_per_ns,
     25             Int_t fadc_slices_written) {
    2326  //
    2427  //  Constructor overloaded II
     
    4548  fwhm_resp_outer = fwhmout;
    4649  integ_resp_outer = integralout;
    47   shape_resp=shape;
    48   shape_resp_outer=shapeout;
    49 
    50     cout<< "[MFadc]  Setting up the MFadc with this values "<< endl ;
    51     cout<< "[MFadc]    - Inner pixels :  "<< endl ;
     50  shape_resp = shape;
     51  shape_resp_outer = shapeout;
     52  fFadcSlicesPerNanosec = fadc_slices_per_ns;
     53  fFadcSlices = fadc_slices_written;
     54
     55  fSlices_mFadc = (Int_t)(TOTAL_TRIGGER_TIME*fFadcSlicesPerNanosec);
     56
     57  for (Int_t i = 0; i < CAMERA_PIXELS; i++)
     58    sig[i] = new Float_t[fSlices_mFadc];
     59
     60  noise = new Float_t[fSlices_mFadc*1001];
     61  noise_outer = new Float_t[fSlices_mFadc*1001];
     62  digital_noise = new Float_t[fSlices_mFadc*1001];
     63
     64  for (Int_t i = 0; i < CAMERA_PIXELS; i++)
     65    {
     66      output[i] = new Float_t[fFadcSlices];
     67      output_lowgain[i] = new Float_t[fFadcSlices];
     68    }
     69
     70  cout<< "[MFadc]  Setting up the MFadc with this values "<< endl ;
     71  cout<< "[MFadc]  FADC sampling frequency: " << fFadcSlicesPerNanosec << " GHz" << endl ;
     72  cout<< "[MFadc]    - Inner pixels :  "<< endl ;
     73
    5274  switch(shape_resp){
    5375  case 0:
     
    82104  //    set up the response shape
    83105  //
     106
     107  //
     108  // First select number of bins for the histogram which will contain the single
     109  // photoelectron response of the FADC. The width of these bins is smaller than that
     110  // of the real FADC slices by a factor SUBBINS (see MFadcDefine.h):
     111  //
     112  if (shape_resp == 1)
     113    fResponseSlicesFadc = (Int_t)(50.*fFadcSlicesPerNanosec*SUBBINS);
     114  // 50 ns range
     115
     116  else
     117    fResponseSlicesFadc = (Int_t)(7*fwhm_resp/2.35*fFadcSlicesPerNanosec*SUBBINS);
     118  // 7 sigma range
     119
     120  sing_resp = new Float_t[fResponseSlicesFadc];
     121  sing_resp_outer = new Float_t[fResponseSlicesFadc];
     122
    84123  Int_t  i ;
    85124 
     
    92131  response_sum_outer = 0.;
    93132
    94   dX  = WIDTH_FADC_TIMESLICE / SUBBINS ;   // Units: ns
     133  dX  = 1. / fFadcSlicesPerNanosec / SUBBINS ;   // Units: ns
    95134  dX2 = dX/2. ;
    96135
     
    102141    fadc_time_offset = trigger_delay-x0; // ns
    103142 
    104     for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) {
    105 
    106       x = i * dX + dX2 ;
     143    for (i = 0; i < fResponseSlicesFadc ; i++ )
     144      { 
     145        x = i * dX + dX2 ;
    107146     
    108       sing_resp[i] = expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ;
    109 
    110       response_sum_inner += sing_resp[i];
    111     }
     147        sing_resp[i] = (Float_t)(expf(-0.5*(x-x0)*(x-x0)/(sigma*sigma)));
     148
     149        response_sum_inner += sing_resp[i];
     150      }
    112151
    113152    break;
     
    121160    p1 = 2.066;
    122161    p2 = 1.568;
    123     p3 = 3; // This sets the peak of the pulse at x ~ 3 ADC slices
     162    p3 = 3; // This will set the peak of the pulse at x ~ 3*3.3 = 10 ns
    124163            // It is just a safe value so that the pulse is well contained.
    125164    p4 = 0.00282;
     
    127166    p6 = 0.2411;
    128167    p7 = -0.009442;
    129     // Define the time before trigger to read FADC signal when it
    130     //  has to be written
    131     fadc_time_offset = trigger_delay-p3*WIDTH_FADC_TIMESLICE; // ns
    132 
    133     for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) { 
    134       x = i * dX + dX2;
    135 
    136       // x has to be converted from ns to units FADC slices:
    137       zed_slices=x/WIDTH_FADC_TIMESLICE-p3;
    138       d=(zed_slices>0)?0.5:-0.5;
    139 
    140       sing_resp[i] =  (p1*exp(-p2*(exp(-p2*zed_slices)+zed_slices))+p4+
    141                        p5*exp(-p2*(exp(-p2*zed_slices)+p6*zed_slices))+p7*d);
    142 
    143       response_sum_inner += sing_resp[i];
    144     }
     168
     169    // Now define the time before trigger to read FADC signal when it
     170    // has to be written. Here FADC_SLICES_PER_NSEC (=0.3) is the value
     171    // for the 300 MHz MAGIC FADCs and must NOT be changed, even if you
     172    // use a faster sampling in the simulation (through the input card
     173    // command "fadc_GHz"), because this is just a conversion of units. The
     174    // parameters of the "pulpo" pulse shape were obtained with the 300 MHz
     175    // FADC and so we convert the time parameter to units of 3.3 ns slices
     176    // just to use the provided parametrization, and no matter what sampling
     177    // frequency we are simulating!
     178
     179    fadc_time_offset = trigger_delay - p3 / FADC_SLICES_PER_NSEC; // ns
     180
     181    for (i=0; i< fResponseSlicesFadc ; i++ )
     182      {
     183        x = i * dX + dX2;
     184
     185        // x has to be converted from ns to units FADC slices of the default
     186        // FADC of 300 MHz (these are just units, and must be these even if you
     187        // are using another sampling frequency!):
     188        //
     189        zed_slices = x * FADC_SLICES_PER_NSEC - p3;
     190        d=(zed_slices>0)?0.5:-0.5;
     191
     192        sing_resp[i] =  (Float_t) (p1*exp(-p2*(exp(-p2*zed_slices)+zed_slices))+
     193                                   p4+p5*exp(-p2*(exp(-p2*zed_slices)+
     194                                                  p6*zed_slices))+p7*d);
     195
     196        response_sum_inner += sing_resp[i];
     197      }
    145198
    146199    break;
     
    162215    fadc_time_offset = trigger_delay-x0; // ns
    163216   
    164     for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) { 
     217    for (i = 0; i < fResponseSlicesFadc ; i++ )
     218      { 
     219        x = i * dX + dX2 ;
    165220     
    166       x = i * dX + dX2 ;
    167      
    168       //
    169       //   the value 1/sqrt(2*Pi*sigma^2) was introduced to normalize
    170       //   the area at the input value After this, the integral
    171       //   of the response will be integ_resp.
    172       //
    173       sing_resp_outer[i] = expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ;
    174       response_sum_outer += sing_resp_outer[i];
    175     }
     221        //
     222        //   the value 1/sqrt(2*Pi*sigma^2) was introduced to normalize
     223        //   the area at the input value After this, the integral
     224        //   of the response will be integ_resp.
     225        //
     226        sing_resp_outer[i] = (Float_t) (expf(-0.5 * (x-x0)*(x-x0) /
     227                                             (sigma*sigma)) ) ;
     228        response_sum_outer += sing_resp_outer[i];
     229      }
    176230    break;
    177231  case 1:
     
    184238    p1 = 2.066;
    185239    p2 = 1.568;
    186     p3 = 3; // This sets the peak of the pulse at x ~ 3 ADC slices
    187                // It is just a safe value so that the pulse is well contained.
     240    p3 = 3; // This sets the peak of the pulse at x ~ 3*3.3 = 10 nanosec
     241            // It is just a safe value so that the pulse is well contained.
    188242    p4 = 0.00282;
    189243    p5 = 0.04093;
    190244    p6 = 0.2411;
    191245    p7 = -0.009442;
    192     // Define the time before trigger to read FADC signal when it
    193     //  has to be written
    194     fadc_time_offset = trigger_delay-p3*WIDTH_FADC_TIMESLICE; // ns
    195 
    196     for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) { 
    197       x = i * dX + dX2;
    198 
    199       zed_slices=x/WIDTH_FADC_TIMESLICE-p3;
    200       d=(zed_slices>0)?0.5:-0.5;
    201 
    202       sing_resp_outer[i] = (p1*exp(-p2*(exp(-p2*zed_slices)+zed_slices))+p4+
    203                             p5*exp(-p2*(exp(-p2*zed_slices)+p6*zed_slices))+p7*d);
    204       response_sum_outer += sing_resp_outer[i];
     246
     247    // Now define the time before trigger to read FADC signal when it
     248    // has to be written. Here FADC_SLICES_PER_NSEC (=0.3) is the value
     249    // for the 300 MHz MAGIC FADCs and must NOT be changed, even if you
     250    // use a faster sampling in the simulation (through the input card
     251    // command "fadc_GHz"), because this is just a conversion of units. The
     252    // parameters of the "pulpo" pulse shape were obtained with the 300 MHz
     253    // FADC and so we convert the time parameter to units of 3.3 ns slices
     254    // just to use the provided parametrization, and no matter what sampling
     255    // frequency we are simulating!
     256
     257    fadc_time_offset = trigger_delay - p3 / FADC_SLICES_PER_NSEC; // ns
     258
     259    for (i=0; i< fResponseSlicesFadc ; i++ )
     260      {
     261        x = i * dX + dX2;
     262
     263        // x has to be converted from ns to units FADC slices of the default
     264        // FADC of 300 MHz (these are just units, and must be these even if you
     265        // are using another sampling frequency!):
     266        //
     267        zed_slices = x * FADC_SLICES_PER_NSEC - p3;
     268        d=(zed_slices>0)?0.5:-0.5;
     269
     270        sing_resp_outer[i] = (Float_t) (p1*exp(-p2*(exp(-p2*zed_slices)+
     271                                                    zed_slices))+p4+
     272                                        p5*exp(-p2*(exp(-p2*zed_slices)+
     273                                                    p6*zed_slices))+p7*d);
     274        response_sum_outer += sing_resp_outer[i];
    205275      }
    206276    break;
     
    220290  //
    221291
    222   for (i=0; i< RESPONSE_SLICES_MFADC ; i++ ) { 
     292  for (i=0; i< fResponseSlicesFadc ; i++ )
     293    { 
    223294      sing_resp[i] *= integ_resp / response_sum_inner * SUBBINS;
    224295      sing_resp_outer[i] *= integ_resp_outer / response_sum_outer * SUBBINS;
    225   }
     296    }
    226297
    227298  //
     
    250321    //
    251322    memset(used, 0, CAMERA_PIXELS*sizeof(Bool_t));
    252     memset(output, 0, CAMERA_PIXELS*FADC_SLICES*sizeof(Float_t));
    253     memset(output_lowgain, 0, CAMERA_PIXELS*FADC_SLICES*sizeof(Float_t));
     323
     324    for (Int_t i = 0; i < CAMERA_PIXELS; i++)
     325      {
     326        memset(output[i], 0, fFadcSlices*sizeof(Float_t));
     327        memset(output_lowgain[i], 0, fFadcSlices*sizeof(Float_t));
     328      }
     329
    254330    //
    255331    // Added 15 01 2004, AM:
    256332    //
    257     memset(sig, 0, (Int_t)(CAMERA_PIXELS*SLICES_MFADC*sizeof(Float_t)));
     333    for (Int_t i = 0; i < CAMERA_PIXELS; i++)
     334      memset(sig[i], 0, (Int_t)(fSlices_mFadc*sizeof(Float_t)));
    258335}
    259336void MFadc::Fill( Int_t iPix, Float_t time,
     
    277354  // fills the information about one single Phe in the Trigger class
    278355  //
    279   // parameter is the number of the pixel and the time-difference to the
    280   // first particle
    281   //
    282   //
     356  // Parameters are the number of the pixel and the time-difference to the
     357  // first photon.
     358  //
     359  //
     360  // AM, Jan 2004: Replaced former FADC simulation (integration of signal)
     361  // with a more realistic one (measuring signal height at discrete points).
     362  //
     363
    283364
    284365  Int_t i, ichan, ichanfadc ;
     
    286367  //
    287368  //   first we have to check if the pixel iPix is used or not until now
    288   //   if this is the first use, reset all signal for that pixels
     369  //   if this is the first use, reset all signal for that pixel
    289370  //
    290   if ( iPix > numpix ) {
    291     cout << " WARNING:  MFadc::Fill() :  iPix greater than Pixels in Camera = "
    292          << numpix
    293          << endl ;
    294     exit(987) ;
    295   }
    296 
    297   if ( used[iPix] == FALSE ) {
    298     used [iPix] = TRUE ;
     371  if ( iPix > numpix )
     372    {
     373      cout << " WARNING: MFadc::Fill() : iPix greater than Pixels in Camera = "
     374           << numpix
     375           << endl;
     376      exit(987);
     377    }
     378
     379  if ( used[iPix] == FALSE )
     380    {
     381      used [iPix] = TRUE;
    299382   
    300     for (i=0; i < (Int_t) SLICES_MFADC; i++ ) {
    301       sig[iPix][i] = 0. ;
    302     }
    303   }
    304 
    305   //
    306   //   then select the time slice to use (ican)
     383      for (i=0; i < (Int_t) fSlices_mFadc; i++ )
     384        sig[iPix][i] = 0.;
     385    }
     386
     387  //
     388  //   then select the time slice to use (ichan)
    307389  //
    308390
    309391  if ( time < TOTAL_TRIGGER_TIME+fadc_time_offset ) {
    310392    //
    311     //   determine the slices number assuming the WIDTH_RESPONSE_MFADC
    312     //   ichan marks the start of the pulse, in number of bins of width 
    313     //   WIDTH_RESPONSE_MFADC (2/3 of a ns), measured from the start of the
    314     //   FADC.
    315     //
    316 
    317     ichan = (Int_t) ( time / ((Float_t) WIDTH_RESPONSE_MFADC ));
     393    // Convert time into units of the width of the analog
     394    // signal histogram, sing_resp:
     395    //
     396    ichan = (Int_t) ( time * fFadcSlicesPerNanosec * SUBBINS);
    318397
    319398    //
    320399    //   putting the response slices in the right sig slices.
    321     //   Be carefull, because both slices have different widths.
    322     //
    323 
    324     //
    325     // AM, Jan 2004: Replaced former FADC simulation (integration of signal)
    326     // with a more realistic one (measuring signal height at discrete points).
    327     //
     400    //   Be careful, because both slices have different widths.
     401    //
     402
     403    // We want to put the single phe response given by sing_resp into the
     404    // array sig[][], but only one of each SUBBINS bins, since the binning
     405    // of sing_resp is finer than that of sig[][]. We want that the start of
     406    // sing_resp coincides with the time "time" with respect to the begining
     407    // of sig[][]
    328408
    329409    // We take the pulse height in the middle of FADC slices, we start in the
     
    332412
    333413    Int_t first_i =  Int_t(SUBBINS/2) - ichan%(Int_t)SUBBINS;
    334     first_i = first_i < 0 ? (Int_t)SUBBINS+first_i : first_i;
    335 
    336 
    337     for ( i = first_i ; i < (Int_t)RESPONSE_SLICES; i += (Int_t)SUBBINS) {     
    338       ichanfadc = (Int_t) ((ichan+i)/SUBBINS) ;
    339       if ( ichanfadc < 0 )
     414    first_i = first_i < 0 ? (Int_t)SUBBINS+first_i : first_i;    //
     415    //
     416    // first_i is the first bin of sing_resp which matches the center of one
     417    // bin of sig[][]
     418    //
     419
     420    for ( i = first_i ; i < (Int_t)fResponseSlicesFadc; i += (Int_t)SUBBINS)
     421      {
     422        ichanfadc = (Int_t) ((ichan+i)/SUBBINS) ;
     423        if ( ichanfadc < 0 )
    340424          continue;
    341425
    342       //
    343       // SLICES_MFADC is by default 48. sig[][] is not the true FADC, which
    344       // is filled from sig[][] in MFadc::TriggeredFadc()
    345       //
    346       if ( (ichanfadc) < (Int_t)SLICES_MFADC ) { 
    347         sig[iPix][ichanfadc] += (amplitude * sing_resp[i] )  ;
    348       }
    349     }
    350 
    351   }
    352   else {
     426        //
     427        // fSlices_mFadc is by default 48. sig[][] is not the true FADC, which
     428        // is filled (from sig[][]) in MFadc::TriggeredFadc()
     429        //
     430        if ( (ichanfadc) < (Int_t) fSlices_mFadc ) 
     431          sig[iPix][ichanfadc] += (amplitude * sing_resp[i] );
     432      }
     433
     434  }
     435  else
    353436    cout << "  WARNING!  Fadc::Fill " << time << "  out of TriggerTimeRange "
    354437         << TOTAL_TRIGGER_TIME+fadc_time_offset << endl ;
    355   }
    356438
    357439}
     
    363445  // for an outer pixel
    364446  //
    365   // parameter is the number of the pixel and the time-difference to the
    366   // first particle
    367   //
     447  // See explanations of the code in function Fill() above
    368448  //
    369449
    370450  Int_t i, ichan, ichanfadc ;
    371451 
    372   //
    373   //   first we have to check if the pixel iPix is used or not until now
    374   //   if this is the first use, reset all signal for that pixels
    375   //
    376   if ( iPix > numpix ) {
    377     cout << " WARNING:  MFadc::FillOuter() :  iPix greater than CAMERA_PIXELS"
    378          << endl ;
    379     exit(987) ;
    380   }
    381 
    382   if ( used[iPix] == FALSE ) {
    383     used [iPix] = TRUE ;
     452  if ( iPix > numpix )
     453    {
     454      cout << " WARNING: MFadc::FillOuter() : iPix greater than CAMERA_PIXELS"
     455           << endl ;
     456      exit(987) ;
     457    }
     458
     459  if ( used[iPix] == FALSE )
     460    {
     461      used [iPix] = TRUE ;
    384462   
    385     for (i=0; i < (Int_t) SLICES_MFADC; i++ ) {
    386       sig[iPix][i] = 0. ;
    387     }
    388   }
    389 
    390   //
    391   //   then select the time slice to use (ican)
    392   //
     463      for (i=0; i < (Int_t) fSlices_mFadc; i++)
     464        sig[iPix][i] = 0.;
     465    }
    393466
    394467
    395468  if ( time < TOTAL_TRIGGER_TIME+fadc_time_offset ) {
    396     //
    397     //   determine the slices number assuming the WIDTH_RESPONSE_MFADC
    398     //
    399     ichan = (Int_t) ( time / ((Float_t) WIDTH_RESPONSE_MFADC ));
    400 
    401     //
    402     //   putting the response slices in the right sig slices.
    403     //   Be carefull, because both slices have different widths.
    404     //
    405 
    406     //
    407     // AM, Jan 2004: Replaced former FADC simulation (integration of signal)
    408     // with a more realistic one (measuring signal height at discrete points).
    409     //
    410 
    411     // We take the pulse height in the middle of FADC slices, we start in the
    412     // first such point after the time "time" (=ichan in response bins). Each
    413     // FADC slice corresponds to SUBBINS response bins (SUBBINS=5 by default).
     469
     470    ichan = (Int_t) ( time * fFadcSlicesPerNanosec * SUBBINS);
    414471
    415472    Int_t first_i =  Int_t(SUBBINS/2) - ichan%(Int_t)SUBBINS;
    416473    first_i = first_i < 0 ? (Int_t)SUBBINS+first_i : first_i;
    417474
    418     for ( i = first_i ; i < (Int_t)RESPONSE_SLICES; i += (Int_t)SUBBINS) {
    419       ichanfadc = (Int_t) ((ichan+i)/SUBBINS) ;
    420 
    421       if ( ichanfadc < 0 )
     475    for ( i = first_i ; i < (Int_t)fResponseSlicesFadc; i += (Int_t)SUBBINS)
     476      {
     477        ichanfadc = (Int_t) ((ichan+i)/SUBBINS);
     478
     479        if ( ichanfadc < 0 )
    422480          continue;
    423481
    424       if ( (ichanfadc) < (Int_t)SLICES_MFADC ) { 
    425         sig[iPix][ichanfadc] += (amplitude * sing_resp_outer[i] )  ;
    426       }
    427     }
    428 
     482        if ( (ichanfadc) < (Int_t)fSlices_mFadc )
     483          sig[iPix][ichanfadc] += (amplitude * sing_resp_outer[i] );
     484      }
     485   
    429486  }
    430487  else {
     
    432489         << TOTAL_TRIGGER_TIME+fadc_time_offset << endl ;
    433490  }
    434 
    435 }
    436 
    437 void MFadc::Set( Int_t iPix, Float_t resp[(Int_t) SLICES_MFADC]) {
     491 
     492}
     493
     494void MFadc::Set( Int_t iPix, Float_t *resp) {
    438495 
    439496  //
     
    459516    used [iPix] = TRUE ;
    460517   
    461     for (i=0; i < (Int_t)SLICES_MFADC; i++ ) {
     518    for (i=0; i < (Int_t)fSlices_mFadc; i++ ) {
    462519      sig[iPix][i] = 0. ;
    463520    }
    464521  }
    465   for ( i = 0 ; i<(Int_t)SLICES_MFADC; i++ ) {
     522  for ( i = 0 ; i<(Int_t)fSlices_mFadc; i++ ) {
    466523    sig[iPix][i] = resp[i] ;
    467524  }
     
    469526}
    470527
    471 void MFadc::AddSignal( Int_t iPix, Float_t resp[(Int_t) SLICES_MFADC]) {
     528void MFadc::AddSignal( Int_t iPix, Float_t *resp) {
    472529 
    473530  //
     
    493550    used [iPix] = TRUE ;
    494551   
    495     for (i=0; i < (Int_t)SLICES_MFADC; i++ ) {
     552    for (i=0; i < (Int_t)fSlices_mFadc; i++ ) {
    496553      sig[iPix][i] = 0. ;
    497554    }
    498555  }
    499   for ( i = 0 ; i<(Int_t)SLICES_MFADC; i++ ) {
     556  for ( i = 0 ; i<(Int_t)fSlices_mFadc; i++ ) {
    500557    sig[iPix][i] += resp[i] ;
    501558  }
     
    534591  for(j=0;j<numpix;j++){
    535592    baseline=0.0;
    536     for(i=0;i<(Int_t) SLICES_MFADC;i++){
     593    for(i=0;i<(Int_t) fSlices_mFadc;i++){
    537594      baseline+=sig[j][i];
    538595    }
    539     baseline=baseline/SLICES_MFADC;
    540     for(i=0;i<(Int_t) SLICES_MFADC;i++){
     596    baseline=baseline/fSlices_mFadc;
     597    for(i=0;i<(Int_t) fSlices_mFadc;i++){
    541598      sig[j][i]=-baseline;
    542599    }
     
    554611
    555612  for(i=0;i<numpix;i++)
    556     for(j=0;j<(Int_t)SLICES_MFADC;j++)
     613    for(j=0;j<(Int_t)fSlices_mFadc;j++)
    557614        sig[i][j]+=pedestal[i];
    558615  //
     
    562619  // to do it for all pixels.
    563620  //
    564 
    565 
    566621}
    567622
     
    585640        if (used[i]){
    586641          fdum=(10*GenOff->Rndm());
    587           for(j=0;j<(Int_t) SLICES_MFADC;j++)
     642          for(j=0;j<(Int_t) fSlices_mFadc;j++)
    588643            sig[i][j]+=fdum;
    589644        }
     
    594649      if (used[pixel]){
    595650        fdum=(10*GenOff->Rndm());
    596         for(j=0;j<(Int_t) SLICES_MFADC;j++)
     651        for(j=0;j<(Int_t) fSlices_mFadc;j++)
    597652          sig[pixel][j]+=fdum;
    598653        }
     
    607662      for(i=0;i<numpix;i++){
    608663        if (used[i]){
    609           for(j=0;j<(Int_t) SLICES_MFADC;j++)
     664          for(j=0;j<(Int_t) fSlices_mFadc;j++)
    610665            sig[i][j]+=offset;
    611666        }
     
    615670
    616671      if (used[pixel]){
    617         for(j=0;j<(Int_t) SLICES_MFADC;j++)
     672        for(j=0;j<(Int_t) fSlices_mFadc;j++)
    618673          sig[pixel][j]+=offset;
    619674      }
     
    632687      <<endl;
    633688
    634   for (i=0;i<(UInt_t (SLICES_MFADC))*1001;i++){
     689  for (i=0;i<(UInt_t (fSlices_mFadc))*1001;i++){
    635690    noise[i]=GenElec->Gaus(0., value1 );
    636691    noise_outer[i]=GenElec->Gaus(0., value2 );
     
    656711    //
    657712
    658     startslice=GenElec->Integer(((Int_t)SLICES_MFADC)*1000);
     713    startslice=GenElec->Integer(((Int_t)fSlices_mFadc)*1000);
    659714
    660715    if ( used[i] == FALSE )
     
    664719            memcpy( (Float_t*)&sig[i][0],
    665720                    (Float_t*)&noise[startslice],
    666                     ((Int_t) SLICES_MFADC)*sizeof(Float_t));
     721                    ((Int_t) fSlices_mFadc)*sizeof(Float_t));
    667722        else
    668723            memcpy( (Float_t*)&sig[i][0],
    669724                    (Float_t*)&noise_outer[startslice],
    670                     ((Int_t) SLICES_MFADC)*sizeof(Float_t));
     725                    ((Int_t) fSlices_mFadc)*sizeof(Float_t));
    671726    }
    672727
     
    677732    {
    678733        if (i < fInnerPixelsNum)
    679             for ( Int_t is=0 ; is< (Int_t)SLICES_MFADC ; is++ )
     734            for ( Int_t is=0 ; is< (Int_t)fSlices_mFadc ; is++ )
    680735                sig[i][is] += noise[startslice+is];
    681736        else
    682             for ( Int_t is=0 ; is< (Int_t)SLICES_MFADC ; is++ )
     737            for ( Int_t is=0 ; is< (Int_t)fSlices_mFadc ; is++ )
    683738                sig[i][is] += noise_outer[startslice+is];
    684739    }
     
    694749      <<endl;
    695750
    696   for (i=0;i<UInt_t(SLICES_MFADC*1001);i++){
     751  for (i=0;i<UInt_t(fSlices_mFadc*1001);i++){
    697752    xrdm=GenElec->Gaus(0., value);
    698753    digital_noise[i]=(xrdm>0?Int_t(xrdm+0.5):Int_t(xrdm-0.5));   
     
    717772        continue;
    718773
    719       startslice=GenElec->Integer((Int_t) SLICES_MFADC*999);
     774      startslice=GenElec->Integer((Int_t) fSlices_mFadc*999);
    720775      //     
    721776      //  Then the noise is introduced for each time slice
    722777      //
    723       for ( Int_t is=0 ; is< FADC_SLICES; is++ )
     778      for ( Int_t is = 0 ; is < fFadcSlices; is++ )
    724779        {
    725780          output[i][is] += digital_noise[startslice+is];
    726           output_lowgain[i][is] += digital_noise[startslice+FADC_SLICES+is];
     781          output_lowgain[i][is] += digital_noise[startslice+fFadcSlices+is];
    727782        }
    728783    }
     
    738793      printf ("Pid %3d",  ip ) ;
    739794
    740       for ( Int_t is=0 ; is < (Int_t)SLICES_MFADC; is++ ) {
     795      for ( Int_t is=0 ; is < (Int_t)fSlices_mFadc; is++ ) {
    741796
    742797        if ( sig[ip][is] > 0. ) {
     
    776831  Int_t  iFirstSlice ;
    777832
    778   iFirstSlice = (Int_t) ( t /  WIDTH_FADC_TIMESLICE ) ;
     833  iFirstSlice = (Int_t) ( t * fFadcSlicesPerNanosec ) ;
    779834
    780835  for ( Int_t ip=0; ip<numpix; ip++ ) {
     
    799854  //    puts the standard response function into the array resp
    800855 
    801   for ( Int_t i=0; i< RESPONSE_SLICES; i++ ) {
    802 
    803     resp[i] = sing_resp[i] ;
    804   }
     856  for ( Int_t i=0; i< fResponseSlicesFadc; i++ )
     857    resp[i] = sing_resp[i];
     858
    805859}
    806860
     
    841895  // Get at random a point in the FADC presimulated digital noise:
    842896  //
    843   startslice=GenElec->Integer((Int_t) SLICES_MFADC*999);
     897  startslice=GenElec->Integer((Int_t) fSlices_mFadc*999);
    844898
    845899  for ( Int_t is=0; is < n_slices ; is++ )
     
    875929  // We had 0.5 for the correct rounding:
    876930  //
    877   iFirstSlice = (Int_t) ( 0.5 + time /  WIDTH_FADC_TIMESLICE ) ;
    878 
    879 
    880   for ( Int_t ip=0; ip<numpix; ip++ )
     931  iFirstSlice = (Int_t) ( 0.5 + time * fFadcSlicesPerNanosec ) ;
     932
     933  for ( Int_t ip = 0; ip < numpix; ip++ )
    881934    {
    882935
     
    887940        // it anyway!
    888941        {
    889           for ( Int_t i=0 ; i < FADC_SLICES ; i++ )
     942          for ( Int_t i=0 ; i < fFadcSlices ; i++ )
    890943            {
    891944              output[ip][i]= pedestal[ip];
     
    896949
    897950      i=0;
    898       for ( Int_t is=iFirstSlice ; is < (iFirstSlice+FADC_SLICES) ; is++ )
     951      for ( Int_t is = iFirstSlice; is < (iFirstSlice+fFadcSlices); is++ )
    899952        {
    900           if (is < (Int_t)SLICES_MFADC)
     953          if (is < (Int_t)fSlices_mFadc)
    901954            {
    902955              output[ip][i] = sig[ip][is];
     
    9481001      sprintf (name, "fadc signal %d", i ) ;
    9491002     
    950       hist = new TH1F(dumm, name, (Int_t)SLICES_MFADC, fadc_time_offset, TOTAL_TRIGGER_TIME+fadc_time_offset);
     1003      hist = new TH1F(dumm, name, (Int_t)fSlices_mFadc, fadc_time_offset, TOTAL_TRIGGER_TIME+fadc_time_offset);
    9511004      //
    9521005      //  fill the histogram
    9531006      //
    9541007     
    955       for (Int_t ibin=1; ibin <=(Int_t)SLICES_MFADC; ibin++) {
    956         hist->SetBinContent (ibin, sig[i][ibin-1]) ;
    957       }
     1008      for (Int_t ibin = 1; ibin <= (Int_t)fSlices_mFadc; ibin++)
     1009        hist->SetBinContent (ibin, sig[i][ibin-1]);
     1010
    9581011
    9591012      //      hist->SetMaximum( 5.);
  • trunk/MagicSoft/Simulation/Detector/include-MFadc/MFadc.hxx

    r5099 r5248  
    5656  Float_t  pedestal[CAMERA_PIXELS] ;  //  Pedestal of FADCs
    5757
    58   Float_t  sig[CAMERA_PIXELS][(Int_t) SLICES_MFADC] ; //  the analog signal for pixels, in bins of width
    59                                                       //  equal to the FADC slice: 50/15 ns, but with a
    60                                                       //  total of SLICES_MFADC (=48 now) bins.
    61   Float_t noise[((Int_t) SLICES_MFADC)*1001];
    62   Float_t noise_outer[((Int_t) SLICES_MFADC)*1001];
    63   Int_t digital_noise[((Int_t) SLICES_MFADC)*1001];
    64 
    65   Float_t  output[CAMERA_PIXELS][FADC_SLICES];  //  the analog signal for pixels that is read after a trigger
    66                                                 //  occurs (high gain). Only 15 (=FADC_SLICES) bins
    67 
    68   Float_t  output_lowgain[CAMERA_PIXELS][FADC_SLICES]; //  analog signal, low gain.
     58  Int_t    fSlices_mFadc;  // Number of simulated FADC slices. Larger than the actual number of slices
     59                           // that will be written, since we have to account for possible delays in the
     60                           // trigger
     61
     62  Int_t fResponseSlicesFadc;
     63
     64  //
     65  //  Float_t sig[CAMERA_PIXELS][] ;
     66  //  the analog signal for pixels, in bins of width
     67  //  equal to the FADC slice: (default 50/15 ns), but with a
     68  //  total of fSlices_mFadc bins (default 48).
     69  //
     70  Float_t *sig[CAMERA_PIXELS];
     71
     72  Float_t *noise;
     73  Float_t *noise_outer;
     74  Float_t *digital_noise;
     75
     76  Float_t  *output[CAMERA_PIXELS];  //  the analog signal for pixels that is read after a trigger
     77                                    //  occurs (high gain).
     78
     79  Float_t  *output_lowgain[CAMERA_PIXELS]; //  analog signal, low gain.
    6980
    7081  Float_t high2low_gain;
     82
    7183  //
    7284  //    first the data for the response function
    7385  //
    74   Int_t shape_resp ;                      // index shape of the phe_response function
    75                                           // = 0 --> Gaussian
    76                                           // = 1 --> Pulpo set-up
    77   Float_t fwhm_resp ;                      // fwhm of the phe_response function (in ns)
    78   Float_t integ_resp ;                      // area below curve of the phe_response function (in counts * ns)
    79   Float_t sing_resp[ RESPONSE_SLICES_MFADC ] ;   // the shape of the phe_response function
     86  Int_t shape_resp;      // index shape of the phe_response function
     87                         // = 0 --> Gaussian
     88                         // = 1 --> Pulpo set-up
     89  Float_t fwhm_resp;     // fwhm of the phe_response function (in ns)
     90  Float_t integ_resp;    // area below curve of the phe_response function (in counts * ns)
     91  Float_t *sing_resp;    // the shape of the phe_response function
     92
     93  Float_t fFadcSlicesPerNanosec; // Number of FADC slices per nanosecond, that is, the
     94                                 // sampling frequency of the FADC.
     95
     96  Int_t fFadcSlices;     // Number of FADC slices that will be written on the output
     97                         // file (same number for high and low gain)
    8098
    8199  //
    82100  //    We may end up with a different reponse for the outer pixels
    83101  //
    84   Int_t shape_resp_outer ;                      // index shape of the phe_response function
    85                                           // = 0 --> Gaussian
    86                                           // = 1 --> Pulpo set-up
    87   Float_t fwhm_resp_outer ;                      // fwhm of the phe_response function (in ns)
    88   Float_t integ_resp_outer ;                      // area below curve of the phe_response function (in counts * ns)
    89   Float_t sing_resp_outer[ RESPONSE_SLICES_MFADC ] ;   // the shape of the phe_response function
     102  Int_t shape_resp_outer ;  // index shape of the phe_response function
     103                            // = 0 --> Gaussian
     104                            // = 1 --> Pulpo set-up
     105  Float_t fwhm_resp_outer ; // fwhm of the phe_response function (in ns)
     106  Float_t integ_resp_outer; // area below curve of the phe_response function (in counts * ns)
     107  Float_t *sing_resp_outer; // the shape of the phe_response function
     108
     109
    90110  //
    91111  //   RandomGenerator for the Electonic Noise
     
    98118                            // in the trigger pixels.
    99119
    100 
    101120public:
    102121
    103   MFadc(Int_t pix=577,
    104         Int_t shape=0,
    105         Float_t ampl=MFADC_RESPONSE_INTEGRAL,
    106         Float_t fwhm=MFADC_RESPONSE_FWHM,
    107         Int_t shapeout=0,
    108         Float_t amplout=MFADC_RESPONSE_INTEGRAL,
    109         Float_t fwhmout=MFADC_RESPONSE_FWHM,
    110         Float_t trig_delay=0.) ;
     122  MFadc(Int_t pix = 577,
     123        Int_t shape = 0,
     124        Float_t ampl = MFADC_RESPONSE_INTEGRAL,
     125        Float_t fwhm = MFADC_RESPONSE_FWHM,
     126        Int_t shapeout = 0,
     127        Float_t amplout = MFADC_RESPONSE_INTEGRAL,
     128        Float_t fwhmout = MFADC_RESPONSE_FWHM,
     129        Float_t trig_delay = 0.,
     130        Float_t fadc_slices_per_ns = FADC_SLICES_PER_NSEC,
     131        Int_t   fadc_slices_written = FADC_SLICES);
    111132 
    112133  void SetSeed(UInt_t seed)  {GenElec->SetSeed(seed);}
     
    120141  void FillOuter( Int_t, Float_t, Float_t  ) ; 
    121142
    122   void Set( Int_t iPix, Float_t res[(Int_t) SLICES_MFADC]);
    123 
    124   void AddSignal( Int_t iPix, Float_t res[(Int_t) SLICES_MFADC]);
     143  void Set( Int_t iPix, Float_t *res);
     144  void AddSignal( Int_t iPix, Float_t *res);
    125145
    126146  void SetPedestals( Int_t ped);
     
    185205  void SetHigh2LowGain(Float_t h2l) {high2low_gain=h2l;}
    186206
    187   Float_t GetShape() {
     207  Int_t GetShape() {
    188208    return shape_resp;
    189209  }
     
    205225  }
    206226
     227  Float_t GetFadcSlicesPerNanosec() {
     228    return fFadcSlicesPerNanosec;
     229  }
     230
     231  Int_t GetResponseSlicesFadc() {
     232    return fResponseSlicesFadc;
     233  }
     234
    207235  Bool_t IsPixelUsed(UInt_t p){
    208236    return used[p];
  • trunk/MagicSoft/Simulation/Detector/include-MLons/MLons.cxx

    r5103 r5248  
    33using namespace std;
    44
    5 MLons::MLons(){
     5MLons::MLons()
     6{
    67  //-----------------------------------------------------------------
    78  //
     
    910  //
    1011
    11   fTrigShape = 0.0;
     12  fTrigShape = 0;
    1213  fAmplTrig = 1.0; 
    1314  fFwhmTrig = 2.0;
    14 
    15   fFadcShape = 0.0;
     15  fFadcSlicesPerNanosec = FADC_SLICES_PER_NSEC;
     16
     17  fFadcShape = 0;
    1618  fIntegFadc = 1.0;
    1719  fFwhmFadc = 2.0;
    1820
    19   RandomNumber = new TRandom() ;
     21  RandomNumber = new TRandom();
    2022  RandomNumber -> SetSeed(0);
    2123
    2224}
    2325
    24 MLons::MLons(Float_t in_shapeT, Float_t in_amplT, Float_t in_FwhmT,
    25              Float_t in_shapeF, Float_t in_integF, Float_t in_FwhmF){
     26MLons::MLons(Int_t in_shapeT, Float_t in_amplT, Float_t in_FwhmT,
     27             Int_t in_shapeF, Float_t in_integF, Float_t in_FwhmF,
     28             Float_t in_Fadc_Slices_per_ns)
     29{
    2630  //--------------------------------------------------------------------
    2731  //
     
    3741  fFwhmFadc = in_FwhmF;
    3842
     43  fFadcSlicesPerNanosec = in_Fadc_Slices_per_ns;
     44
     45  MSLStored = new MStarLight;
     46
    3947  RandomNumber = new TRandom() ;
    4048  RandomNumber -> SetSeed(0);
    4149}
    4250
    43 void MLons::Reset() {
     51void MLons::Reset()
     52{
    4453  //-----------------------------------------------------------------
    4554  //
     
    4756  //
    4857
    49   fTrigShape   = 0. ;
    50   fAmplTrig    = 0. ;
    51   fFwhmTrig    = 0. ;
    52 
    53   fFadcShape   = 0. ;
    54   fIntegFadc    = 0. ;
    55   fFwhmFadc    = 0. ;
    56 
    57   MSLStored.Reset();
     58  fTrigShape   = 0;
     59  fAmplTrig    = 0.;
     60  fFwhmTrig    = 0.;
     61
     62  fFadcShape   = 0;
     63  fIntegFadc   = 0.;
     64  fFwhmFadc    = 0.;
     65
     66  MSLStored->Reset();
    5867
    5968}
     
    110119}
    111120
    112 void MLons::ReadBinaryMStarLight(char *filename){
    113 
    114   MSLStored.ReadBinary(filename);
    115 
    116 }
    117 
    118 Int_t MLons::CheckTrig(){
     121void MLons::ReadBinaryMStarLight(char *filename)
     122{
     123  MSLStored->ReadBinary(filename);
     124}
     125
     126Int_t MLons::CheckTrig()
     127{
    119128  //--------------------------------------------------------------------
    120129  //
     
    122131  //
    123132
    124   if (  fAmplTrig == MSLStored.GetAmplTrig() &&
    125         fFwhmTrig == MSLStored.GetFwhmTrig())
     133  if (  fAmplTrig == MSLStored->GetAmplTrig() &&
     134        fFwhmTrig == MSLStored->GetFwhmTrig())
    126135    return 1;
    127136
     137  cout << "1 phe- pulse amplitudes for trigger (mV): " << fAmplTrig << "    "
     138       << MSLStored->GetAmplTrig() << endl;
     139  cout << "1 phe- pulse FWHM for trigger (ns):       " << fFwhmTrig << "    "
     140       << MSLStored->GetFwhmTrig() << endl;
     141
    128142  return 0;
    129143}
    130144
    131 Int_t MLons::CheckFADC(){
     145Int_t MLons::CheckFADC()
     146{
    132147  //--------------------------------------------------------------------
    133148  //
     
    135150  //
    136151
    137   if (  fIntegFadc == MSLStored.GetIntegFadc() &&
    138         fFwhmFadc == MSLStored.GetFwhmFadc() &&
    139         fFadcShape == MSLStored.GetShapeFadc())
     152  if (  fIntegFadc == MSLStored->GetIntegFadc() &&
     153        fFwhmFadc == MSLStored->GetFwhmFadc() &&
     154        fFadcShape == MSLStored->GetShapeFadc() &&
     155        fFadcSlicesPerNanosec == MSLStored->GetFadcSlicesPerNanosec() )
    140156    return 1;
    141157
     158  cout << "1 phe- FADC pulse shape :             " << fFadcShape << "    "
     159       << MSLStored->GetShapeFadc() <<  endl;
     160  cout << "1 phe- FADC pulse integral (counts) : " << fIntegFadc << "    "
     161       << MSLStored->GetIntegFadc() << endl;
     162  cout << "1 phe- FADC pulse FWHM (ns) :         " << fFwhmFadc  << "    "
     163       << MSLStored->GetFwhmFadc() <<  endl;
     164  cout << "FADC sampling frequencies (GHz) :     " << fFadcSlicesPerNanosec << "    "
     165       << MSLStored->GetFadcSlicesPerNanosec() << endl;
     166
    142167  return 0;
    143168}
    144169
    145170Int_t MLons::GetResponse(Float_t in_br, Float_t in_pre,
    146                          Float_t *out_tr, Float_t *out_Fr){
     171                         Float_t *out_tr, Float_t *out_Fr)
     172{
    147173  //-------------------------------------------------------------------------
    148174  //
     
    154180  Char_t cstoredbright[10];
    155181
    156   Int_t i;
    157182  Int_t bin;
    158   Float_t start_bin;
    159   Float_t time;
    160 
     183  Float_t start_time;
     184
     185
     186  //
    161187  // The following code line commented means that the simulation will crash if
    162188  // some pixel ask for more lons than what we have in the database.
    163189  // The following code line uncommented would mean that the simulation does
    164   //  not crash if a pixel ask for more than it is simulated but would
    165   // assign to it lees lons.
    166   if (in_br>49.9) in_br=49.9;  //  To avoid error for high required brightness
    167                                  //  It has to be improved
     190  // not crash if a pixel ask for more than it is simulated but would
     191  // assign to it less lons.
     192  // I think this is unnecessary now. AM 5/10/2004
     193  //  if (in_br>49.9) in_br=49.9;    //  To avoid error for high required brightness
     194  //                                 //  It has to be improved
     195  //
     196
    168197
    169198  //  Check if the the brightness is the same than the last time.
    170   //  NOTE: Same means, the smae inside the required precision!!!
    171 
    172   if(in_br<1.0){
     199  //  NOTE: Same means, the same inside the required precision!!!
     200
     201  if(in_br<=1.0){
    173202    sprintf(cbright,"%4.2f",in_br);
    174     sprintf(cstoredbright,"%4.2f",MSLStored.GetBrightness());
     203    sprintf(cstoredbright,"%4.2f",MSLStored->GetBrightness());
    175204  }
    176205  else{
    177206    sprintf(cbright,"%3.1f",in_br);
    178     sprintf(cstoredbright,"%3.1f",MSLStored.GetBrightness());
     207    sprintf(cstoredbright,"%3.1f",MSLStored->GetBrightness());
    179208  }
    180   if (strcmp(cbright, cstoredbright)){
    181    
    182     // Building the filename
    183     // Note: it would be nice to get an algorithm that gets the name of
    184     // files it needs to get brightness as a function of precison(in_pre),
    185     // brightnes (in_br) and the Star_files that are in the "Path" directory.
    186 
    187     strcpy(filename_slt, & path[0]);
    188     strcat(filename_slt, "Brightness");
    189     strcat(filename_slt, & cbright[0]);
     209
     210  if (strcmp(cbright, cstoredbright))
     211    {
     212      // Building the filename
     213      // Note: it would be nice to get an algorithm that gets the name of
     214      // files it needs to get brightness as a function of precison(in_pre),
     215      // brightnes (in_br) and the Star_files that are in the "Path" directory.
     216
     217      strcpy(filename_slt, & path[0]);
     218      strcat(filename_slt, "Brightness");
     219      strcat(filename_slt, & cbright[0]);
    190220 
    191     strcat(filename_slt, ".slt");
     221      strcat(filename_slt, ".slt");
    192222 
    193     // If brightness is different it check if the new file has the
    194     // required parameters.
    195     // Note: I could be faster to store the whole trigger and fadc
    196     // response and use it while brightness does not change. Then the
    197     // root file should be open and close here.
    198 
    199     ReadBinaryMStarLight( & filename_slt[0]);
    200 
    201     if (!(CheckTrig() && CheckFADC())) {
    202       cout<<"ERROR: The Database for light from Night Sky Background is wrong"<<endl<<"       Make sure that you generated the database with the same shape for Fadc and trigger taht you are asking now."<<endl;
    203       return 0;
     223      // If brightness is different it check if the new file has the
     224      // required parameters.
     225      // Note: I could be faster to store the whole trigger and fadc
     226      // response and use it while brightness does not change. Then the
     227      // root file should be open and close here.
     228
     229      MSLStored->ReadBinary(filename_slt);
     230
     231      if (!(CheckTrig() && CheckFADC()))
     232        {
     233          cout << "ERROR: The Database for light from Night Sky Background is wrong"<<endl;
     234          cout << "       Make sure that you generated the database with the same shape" << endl;
     235          cout << "       for Fadc and trigger that you are asking now."<<endl;
     236          return 0;
     237        }
     238      MSLStored->SetBrightness(in_br);
     239
    204240    }
    205     MSLStored.SetBrightness(in_br);
    206 
    207  }
    208241
    209242  // Random number that decides the set of bins that the program will get
    210   start_bin=RandomNumber->Uniform(1.0e4);
     243  start_time = RandomNumber->Uniform(TIMERANGE);
    211244
    212245  //  Filling trigger response
    213246
    214   bin=(Int_t)(start_bin*4);
    215 
    216   for (i=0;i<TRIGGER_TIME_SLICES;i++){
    217 
    218     time=((float)i)/SLICES_PER_NSEC;
    219    
    220     if (time>(bin-start_bin*4.0)/4.0) bin++;
    221 
    222     if (bin>=TRIGBINS) bin=bin-TRIGBINS;
    223 
    224     out_tr[i]=MSLStored.GetTrig(bin);
    225   }
     247  bin = (Int_t)(start_time*TRIG_SLICES_PER_NSEC);
     248
     249
     250  if (bin+TRIGGER_TIME_SLICES > MSLStored->GetBinsTrig())
     251    {
     252      memcpy (out_tr, MSLStored->GetTrigPointer(bin),
     253              (UInt_t) (MSLStored->GetBinsTrig()-bin)*sizeof(Float_t));
     254      memcpy (out_tr, MSLStored->GetTrigPointer(0),
     255              (UInt_t) (bin+TRIGGER_TIME_SLICES-MSLStored->GetBinsTrig())*sizeof(Float_t));
     256    }
     257  else
     258    memcpy (out_tr, MSLStored->GetTrigPointer(bin),
     259            (UInt_t) TRIGGER_TIME_SLICES*sizeof(Float_t));
     260
    226261
    227262  //  Filling fadc response
    228263
    229   bin=(Int_t) (start_bin*0.3);
    230 
    231   for (i=0;i<(Int_t) SLICES_MFADC;i++){
    232 
    233     time=((float)i)*WIDTH_FADC_TIMESLICE;
    234    
    235     if (time>(bin-start_bin*0.3)/0.3) bin++;
    236 
    237     if (bin>=FADCBINS) bin=bin-FADCBINS;
    238 
    239     out_Fr[i]=MSLStored.GetFadc(bin);
    240   }
     264  // Start bin in the NSB database:
     265  bin = (Int_t) (start_time*MSLStored->GetBinsFadc()/MSLStored->GetTimeRange());
     266
     267  // If we go over the end of the database, continue at the begining of it:
     268  if (bin + (Int_t)(TOTAL_TRIGGER_TIME*fFadcSlicesPerNanosec) > MSLStored->GetBinsFadc())
     269    {
     270      memcpy (out_Fr, MSLStored->GetFadcPointer(bin),
     271              (Int_t)(MSLStored->GetBinsFadc()-bin)*sizeof(Float_t));
     272
     273      memcpy (out_Fr, MSLStored->GetFadcPointer(0),
     274              (Int_t)(bin + TOTAL_TRIGGER_TIME*fFadcSlicesPerNanosec -
     275                       MSLStored->GetBinsFadc())*sizeof(Float_t));
     276    }
     277  else
     278    memcpy (out_Fr, MSLStored->GetFadcPointer(bin),
     279            (Int_t)(TOTAL_TRIGGER_TIME*fFadcSlicesPerNanosec*sizeof(Float_t)));
    241280
    242281  return 1;
  • trunk/MagicSoft/Simulation/Detector/include-MLons/MLons.hxx

    r5103 r5248  
    3333//
    3434
    35 class MLons {
     35class MLons
     36{
    3637
    3738private:
    3839
    39   Char_t   path[256]    ;   // Location of StarLight files
     40  Char_t   path[256]   // Location of StarLight files
    4041
    41   MStarLight MSLStored  ;   // MStarLight in memmory
     42  MStarLight *MSLStored;  // MStarLight in memory
    4243
    43   Float_t  fTrigShape   ;   // a number that indicate the shape type of
    44                             // the signal   
    45                             // = 0 --> a gaussian 
    46   Float_t  fAmplTrig    ;   // the amplitude of the trigger in mV
    47   Float_t  fFwhmTrig    ;   // the width of the signal in nsec
     44  Int_t  fTrigShape;      // a number that indicate the shape type of
     45                          // the signal   
     46                          // = 0 --> a gaussian 
     47  Float_t  fAmplTrig   // the amplitude of the trigger in mV
     48  Float_t  fFwhmTrig   // the width of the signal in nsec
    4849
    49   Float_t  fFadcShape   ;   // a number that indicate the shape type of
    50                             // the signal   
    51                             // = 0 --> a gaussian 
    52   Float_t  fIntegFadc    ;  // the integral of the single phe response
    53                             // in the FADC (in FADC counts)
    54   Float_t  fFwhmFadc    ;   // the width of the signal in nsec
     50  Int_t    fFadcShape;    // a number that indicate the shape type of
     51                          // the signal   
     52                          // = 0 --> a gaussian 
     53  Float_t  fIntegFadc  // the integral of the single phe response
     54                          // in the FADC (in FADC counts)
     55  Float_t  fFwhmFadc   // the width of the signal in nsec
    5556
    56   TRandom  *RandomNumber;   // RandomGenerator
     57  Float_t  fFadcSlicesPerNanosec; // The sampling frequency (GHz) of the FADC
     58
     59  TRandom  *RandomNumber; // RandomGenerator
    5760
    5861public:
     
    6063  MLons() ;
    6164
    62   MLons(Float_t in_shapeT, Float_t in_amplT, Float_t in_FwhmT,
    63         Float_t in_shapeF, Float_t in_integF, Float_t in_FwhmF) ;
     65  MLons(Int_t in_shapeT, Float_t in_amplT, Float_t in_FwhmT,
     66        Int_t in_shapeF, Float_t in_integF, Float_t in_FwhmF,
     67        Float_t in_Fadc_Slices_per_ns);
    6468
    6569  void Reset() ;
     
    7882  Float_t GetIntegFadc() ;
    7983  Float_t GetFwhmFadc() ;
     84  Float_t GetFadcSlicesPerNanosec() {return fFadcSlicesPerNanosec;}
    8085
    8186  void GetPath(Char_t *out);
  • trunk/MagicSoft/Simulation/Detector/include-MTrigger/MTrigger.cxx

    r5104 r5248  
    206206  x0 = 3*sigma ;
    207207 
    208   for (i=0; i< RESPONSE_SLICES ; i++ ) { 
    209 
    210     x = i * (1./((Float_t)SLICES_PER_NSEC))
    211       + (1./( 2 * (Float_t)SLICES_PER_NSEC ))  ;
     208  for (i=0; i< RESPONSE_SLICES_TRIG ; i++ ) { 
     209
     210    x = i * (1./((Float_t)TRIG_SLICES_PER_NSEC))
     211      + (1./( 2 * (Float_t)TRIG_SLICES_PER_NSEC ))  ;
    212212   
    213     sing_resp[i] =
     213    sing_resp[i] = (Float_t)
    214214      ampl_resp * expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ;
    215215 
     
    224224  Int_t imax  = 0  ;
    225225  Float_t max = 0. ;
    226   for (i=0; i< RESPONSE_SLICES ; i++ ) { 
     226  for (i=0; i< RESPONSE_SLICES_TRIG ; i++ ) { 
    227227    if ( sing_resp[i] > max ) {
    228228      imax = i ;
     
    231231  }
    232232 
    233   peak_time = ( (Float_t) imax )  / ( (Float_t) SLICES_PER_NSEC ) ;
     233  peak_time = ( (Float_t) imax )  / ( (Float_t) TRIG_SLICES_PER_NSEC ) ;
    234234 
    235235
     
    357357 
    358358  for ( i = 0 ; i < 5 ; i++) {
    359     SlicesFirst[i]  = -50 ;
    360     SlicesSecond[i] = -50 ;
     359    SlicesFirst[i]  = 0;
     360    SlicesSecond[i] = 0;
    361361    PixelsFirst[i]  = -1;
    362362    PixelsSecond[i] = -1;
     
    454454  x0 = 3*sigma ;
    455455 
    456   for (i=0; i< RESPONSE_SLICES ; i++ ) { 
    457 
    458     x = i * (1./((Float_t)SLICES_PER_NSEC))
    459       + (1./( 2 * (Float_t)SLICES_PER_NSEC ))  ;
     456  for (i=0; i< RESPONSE_SLICES_TRIG ; i++ ) { 
     457
     458    x = i * (1./((Float_t)TRIG_SLICES_PER_NSEC))
     459      + (1./( 2 * (Float_t)TRIG_SLICES_PER_NSEC ))  ;
    460460   
    461     sing_resp[i] =
     461    sing_resp[i] = (Float_t)
    462462      ampl_resp * expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ;
    463463 
     
    472472  Int_t imax  = 0  ;
    473473  Float_t max = 0. ;
    474   for (i=0; i< RESPONSE_SLICES ; i++ ) { 
     474  for (i=0; i< RESPONSE_SLICES_TRIG ; i++ ) { 
    475475    if ( sing_resp[i] > max ) {
    476476      imax = i ;
     
    479479  }
    480480 
    481   peak_time = ( (Float_t) imax )  / ( (Float_t) SLICES_PER_NSEC ) ;
     481  peak_time = ( (Float_t) imax )  / ( (Float_t) TRIG_SLICES_PER_NSEC ) ;
    482482 
    483483  //
     
    588588 
    589589  for ( i = 0 ; i < 5 ; i++) {
    590     SlicesFirst[i]  = -50 ;
    591     SlicesSecond[i] = -50 ;
     590    SlicesFirst[i]  = 0 ;
     591    SlicesSecond[i] = 0 ;
    592592    PixelsFirst[i]  = -1;
    593593    PixelsSecond[i] = -1;
     
    683683  x0 = 3*sigma ;
    684684 
    685   for (i=0; i< RESPONSE_SLICES ; i++ ) { 
    686 
    687     x = i * (1./((Float_t)SLICES_PER_NSEC))
    688       + (1./( 2 * (Float_t)SLICES_PER_NSEC ))  ;
     685  for (i=0; i< RESPONSE_SLICES_TRIG ; i++ ) { 
     686
     687    x = i * (1./((Float_t)TRIG_SLICES_PER_NSEC))
     688      + (1./( 2 * (Float_t)TRIG_SLICES_PER_NSEC ))  ;
    689689   
    690     sing_resp[i] =
     690    sing_resp[i] = (Float_t)
    691691      ampl_resp * expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ;
    692692 
     
    701701  Int_t imax  = 0  ;
    702702  Float_t max = 0. ;
    703   for (i=0; i< RESPONSE_SLICES ; i++ ) { 
     703  for (i=0; i< RESPONSE_SLICES_TRIG ; i++ ) { 
    704704    if ( sing_resp[i] > max ) {
    705705      imax = i ;
     
    708708  }
    709709 
    710   peak_time = ( (Float_t) imax )  / ( (Float_t) SLICES_PER_NSEC ) ;
     710  peak_time = ( (Float_t) imax )  / ( (Float_t) TRIG_SLICES_PER_NSEC ) ;
    711711 
    712712  //
     
    772772 
    773773  for ( i = 0 ; i < 5 ; i++) {
    774     SlicesFirst[i]  = -50 ;
    775     SlicesSecond[i] = -50 ;
     774    SlicesFirst[i]  = 0 ;
     775    SlicesSecond[i] = 0 ;
    776776    PixelsFirst[i]  = -1;
    777777    PixelsSecond[i] = -1;
     
    843843 
    844844  for ( i = 0 ; i < 5 ; i++) {
    845     SlicesFirst[i]  = -50 ;
     845    SlicesFirst[i]  = 0 ;
    846846    PixelsFirst[i]  = -1;
    847847  }
     
    872872  //
    873873  //     Fills the information of one single Phe electron that
    874   //     comes from the shower
     874  //     comes from the NSB
    875875  //
    876876
     
    892892  //
    893893  //     Fills the information of one single Phe electron that
    894   //     comes from the shower
    895   //
     894  //     comes from a star
    896895
    897896  //
     
    969968    //
    970969
    971     Int_t ichan = (Int_t) ( time * ((Float_t) SLICES_PER_NSEC) ) ;
     970    Int_t ichan = (Int_t) ( time * ((Float_t) TRIG_SLICES_PER_NSEC) ) ;
    972971
    973972    //
     
    975974    //
    976975
    977     for ( i = 0 ; i<RESPONSE_SLICES; i++ ) {
     976    for ( i = 0 ; i<RESPONSE_SLICES_TRIG; i++ ) {
    978977     
    979978      if ( (ichan+i) >= 0  && 
     
    11321131  x0 = 3*sigma ;
    11331132 
    1134   for (i=0; i< RESPONSE_SLICES ; i++ ) { 
    1135 
    1136     x = i * (1./((Float_t)SLICES_PER_NSEC))
    1137       + (1./( 2 * (Float_t)SLICES_PER_NSEC ))  ;
     1133  for (i=0; i< RESPONSE_SLICES_TRIG ; i++ ) { 
     1134
     1135    x = i * (1./((Float_t)TRIG_SLICES_PER_NSEC))
     1136      + (1./( 2 * (Float_t)TRIG_SLICES_PER_NSEC ))  ;
    11381137   
    1139     sing_resp[i] =
     1138    sing_resp[i] = (Float_t)
    11401139      ampl_resp * expf(-0.5 * (x-x0)*(x-x0) / (sigma*sigma) ) ;
    11411140 
     
    12441243  //    puts the standard response function into the array resp
    12451244
    1246   for ( Int_t i=0; i< RESPONSE_SLICES; i++ ) {
     1245  for ( Int_t i=0; i< RESPONSE_SLICES_TRIG; i++ ) {
    12471246
    12481247    resp[i] = sing_resp[i] ;
     
    12881287
    12891288
    1290   Int_t  jmax = (Int_t) (gate_leng * SLICES_PER_NSEC )  ;
     1289  Int_t  jmax = (Int_t) (gate_leng * TRIG_SLICES_PER_NSEC )  ;
    12911290
    12921291  //
     
    15721571      if (SlicesZero[iSli]){
    15731572        //
    1574         //  Loop over trigger cells. It is topology analisy,
    1575         //  therefore it is keep here after multiplicity and
     1573        //  Loop over trigger cells. It is topology analysis,
     1574        //  therefore it is kept here after multiplicity and
    15761575        //  threshold checks.
    15771576        //
     
    16451644                  SlicesFirst[nFirst++] = iSli ; // We save time when it triggers
    16461645                  iReturn++ ;
    1647                   iSli+=(50*SLICES_PER_NSEC);  // We skip the following 50 ns (dead time)
     1646                  iSli+=(LEVEL1_DEAD_TIME*TRIG_SLICES_PER_NSEC);  // We skip the following 50 ns (dead time)
    16481647                  iCell=TRIGGER_CELLS;         // We skip the remaining trigger cells
    16491648                  break ;
     
    16751674                  SlicesFirst[nFirst++] = iSli ; //  We save when it triggers
    16761675                  iReturn++ ;
    1677                   iSli+=(50*SLICES_PER_NSEC);  // We skip the following 50 ns (dead time)
     1676                  iSli+=(LEVEL1_DEAD_TIME*TRIG_SLICES_PER_NSEC);  // We skip the following 50 ns (dead time)
    16781677                  iCell=TRIGGER_CELLS;         // We skip the remaining trigger cells
    16791678                  break ;
     
    17681767                    SlicesFirst[nFirst++] = iSli ; //  We save time when it triggers
    17691768                    iReturn++ ;
    1770                     iSli+=(50*SLICES_PER_NSEC);  // We skip the following 50 ns (dead time)
     1769                    iSli+=(LEVEL1_DEAD_TIME*TRIG_SLICES_PER_NSEC);  // We skip the following 50 ns (dead time)
    17711770                    iCell=TRIGGER_CELLS;         // We skip the remaining trigger cells
    17721771                    break ;
     
    18631862  //  It gives the time for the il trigger at first level
    18641863
    1865   return((Float_t) ((Float_t) SlicesFirst[il]/((Float_t) SLICES_PER_NSEC)));
     1864  return((Float_t) ((Float_t) SlicesFirst[il]/((Float_t) TRIG_SLICES_PER_NSEC)));
    18661865}
    18671866
     
    18851884
    18861885  // Translation from ns to slices
    1887   iNumSli=(int) (overlaping_time*SLICES_PER_NSEC);
     1886  iNumSli=(int) (overlaping_time*TRIG_SLICES_PER_NSEC);
    18881887  if (iNumSli<1) iNumSli=1;
    18891888
     
    19011900
    19021901}
    1903 
    1904 
    1905 
  • trunk/MagicSoft/Simulation/Detector/include-MTrigger/MTrigger.hxx

    r5099 r5248  
    109109  //    first the data for the response function
    110110  //
    111   Float_t fwhm_resp ;                      // fwhm of the phe_response function
    112   Float_t ampl_resp ;                      // amplitude of the phe_response function (in mV)
    113   Float_t sing_resp[ RESPONSE_SLICES ] ;   // the shape of the phe_response function
    114   Float_t peak_time  ;                      // the time from the start of the response function to the maximum peak
     111  Float_t fwhm_resp ;                       // fwhm of the phe_response function
     112  Float_t ampl_resp ;                       // amplitude of the phe_response function (in mV)
     113  Float_t sing_resp[RESPONSE_SLICES_TRIG] ; // the shape of the phe_response function
     114  Float_t peak_time  ;                      // the time from the start of the response
     115                                            // function to the maximum peak
    115116
    116117  TH1F     *histPmt ;
Note: See TracChangeset for help on using the changeset viewer.