// compile with:
// g++ -o plotcsv.exe plotcsv.cpp `root-config --cflags --glibs`
//
#include "TH1F.h"
#include "TProfile.h"
#include "TMath.h"
#include "TF1.h"
#include "TLegend.h"
#include "TCanvas.h"
#include "TLine.h"
 //
#include "TROOT.h"
//#include "TStyle.h"
#include "TTree.h"
#include "TFile.h"
#include "TGraphErrors.h"
#include "TStyle.h"
#include "TLine.h"
#include <string>
#include <cmath>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
//
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

using namespace std;

int plotcsv(const char *filename = "")
{
  TH1F* hPeak0MeanAll;
  TH1F* hPeak0RmsAll;
  TH1F* hPeak0Mean;
  TH1F* hPeak0Rms;
  TH1F* hPeak1MeanAll;
  TH1F* hPeak1RmsAll;
  TH1F* hPeak1Mean;
  TH1F* hPeak1Rms;
  TH1F* hPeak2MeanAll;
  TH1F* hPeak2RmsAll;
  TH1F* hPeak2Mean;
  TH1F* hPeak2Rms;
  TH1F* hPed0MeanAll;
  TH1F* hPed0RmsAll;
  TH1F* hPed0Mean;
  TH1F* hPed0Rms;
  TH1F* hPed1MeanAll;
  TH1F* hPed1RmsAll;
  TH1F* hPed1Mean;
  TH1F* hPed1Rms;
  TH1F* hPed2MeanAll;
  TH1F* hPed2RmsAll;
  TH1F* hPed2Mean;
  TH1F* hPed2Rms;
  FILE *fcsv;
  int filetype = 0;
  FILE *flimits;
  int limititem = 0;
  float peak_min_mean[3] = {0};
  float peak_max_mean[3] = {0};
  float peak_max_rms[3] = {0};
  float ped_min_mean[4] = {0};
  float ped_max_mean[4] = {0};
  float ped_max_rms[4] = {0};
  float cluster_min_mean;
  float cluster_max_mean;
  float cluster_max_rms;
  int min_clusters, max_clusters;
  int cluster_thresh;
  TH1F *hClLengthMean;
  TH1F *hClLengthRms;
  TH1F *hClLengthEntries;
  TH1F *hClLengthMeanAll;
  TH1F *hClLengthRmsAll;
  TH1F *hClLengthEntriesAll;
  int oldsaltronb = 0;
  int nbchips = 0;
  int chipnumbers[1000];

  memset(chipnumbers,0,sizeof(chipnumbers));
  if (strstr(filename,"pedsub") != NULL ) filetype = 1;
  else if (strstr(filename,"zerosup") != NULL ) filetype = 2;
  else if (strstr(filename,"pedestal") != NULL ) filetype = 3;
  else {
    printf("%s not legal\n",filename);
    return 1;
  }
  //  printf("FILETYPE %d\n",filetype);
  fcsv = fopen(filename,"r");
  if (fcsv == NULL) {
    printf("File %s not found\n",filename);
    return 2;
  }
  int mcm,chipnb,gain,shaper,polarity,pgsource;
  char limitbuffer[128];
  char limitfile[512];
  int limitentry = 0;
  int isshaperrun = 0;
  if (filetype == 1) { // read limits file for pedsub
    sscanf(filename,"saltro-mcm%d-c%1d-pedsub-g%1d-s%1d-p%1d-s%1d-%s",&mcm,&chipnb,&gain,&shaper,&polarity,&pgsource,limitbuffer);
    if (strstr(filename,"sh.csv") == NULL ) {
      sprintf(limitfile,"plotchippedsub-g%d-s%d-p%d-s%d.txt",gain,shaper,polarity,pgsource);
      isshaperrun = 0;
    }
    else {
      sprintf(limitfile,"plotchippedsubsh-g%d-s%d-p%d-s%d.txt",gain,shaper,polarity,pgsource);
      isshaperrun = 1;
    }
    flimits = fopen(limitfile,"r");
    if (flimits != NULL) {
      while (fgets(limitbuffer,sizeof(limitbuffer),flimits) != NULL) {
	if (limitbuffer[0] != '#') {
	  switch(limititem) {
	  case 0: sscanf(limitbuffer,"%f %f %f",&peak_min_mean[0],&peak_max_mean[0],&peak_max_rms[0]); break;
	  case 1: sscanf(limitbuffer,"%f %f %f",&peak_min_mean[1],&peak_max_mean[1],&peak_max_rms[1]); break;
	  case 2: sscanf(limitbuffer,"%f %f %f",&peak_min_mean[2],&peak_max_mean[2],&peak_max_rms[2]); break;
	  case 3: sscanf(limitbuffer,"%f %f %f",&ped_min_mean[0],&ped_max_mean[0],&ped_max_rms[0]); break;
	  case 4: sscanf(limitbuffer,"%f %f %f",&ped_min_mean[1],&ped_max_mean[1],&ped_max_rms[1]); break;
	  case 5: sscanf(limitbuffer,"%f %f %f",&ped_min_mean[2],&ped_max_mean[2],&ped_max_rms[2]); break;
	  case 6: sscanf(limitbuffer,"%d %f %f %f",&cluster_thresh,&cluster_min_mean,&cluster_max_mean,&cluster_max_rms); break;
	  }
	  limititem++;
	}
      }
      fclose(flimits);
    }
  }
  else if (filetype == 2) { // read limits file for zerosup
    sscanf(filename,"saltro-mcm%d-c%1d-zerosup-g%1d-s%1d-p%1d-s%1d-%s",&mcm,&chipnb,&gain,&shaper,&polarity,&pgsource,limitbuffer);
    if (strstr(filename,"sh.csv") == NULL ) {
      sprintf(limitfile,"plotchipzsuppeaks-g%d-s%d-p%d-s%d.txt",gain,shaper,polarity,pgsource);
    }
    else {
      sprintf(limitfile,"plotchipzsuppeakssh-g%d-s%d-p%d-s%d.txt",gain,shaper,polarity,pgsource);
    }
    flimits = fopen(limitfile,"r");
    if (flimits != NULL) {
      while (fgets(limitbuffer,sizeof(limitbuffer),flimits) != NULL) {
	if (limitbuffer[0] != '#') {
	  switch(limititem) {
	  case 0: sscanf(limitbuffer,"%f %f %f",&peak_min_mean[0],&peak_max_mean[0],&peak_max_rms[0]); break;
	  case 1: sscanf(limitbuffer,"%f %f %f",&peak_min_mean[1],&peak_max_mean[1],&peak_max_rms[1]); break;
	  case 2: sscanf(limitbuffer,"%f %f %f",&peak_min_mean[2],&peak_max_mean[2],&peak_max_rms[2]); break;
	  case 3: sscanf(limitbuffer,"%f %f %f %d %d",&cluster_min_mean,&cluster_max_mean,&cluster_max_rms,&min_clusters,&max_clusters); break;
	  }
	  limititem++;
	}
      }
      fclose(flimits);
    }
  }
  if (filetype == 3) { // read limits file for pedestals
    sscanf(filename,"saltro-mcm%d-c%1d-pedestal-g%1d-s%1d-p%1d%s",&mcm,&chipnb,&gain,&shaper,&polarity,limitbuffer);
    if (shaper == 0) {
      sprintf(limitfile,"plotchipped-gains-g%d-s%d-p%d-s3.txt",gain,shaper,polarity);
      limitentry = gain;
    }
    else {
      sprintf(limitfile,"plotchipped-shapers-g%d-s%d-p%d-s3.txt",gain,shaper,polarity);
      switch (shaper) {
      case 0: limitentry = 0;
      case 1: limitentry = 1;
      case 2: limitentry = 2;
      case 3: limitentry = 3;
      }
    }
    printf("MCM %d GAIN %d SHAPER %d POLARITY %d\n%s\n",mcm,gain,shaper,polarity,limitfile);
    flimits = fopen(limitfile,"r");
    if (flimits != NULL) {
      while (fgets(limitbuffer,sizeof(limitbuffer),flimits) != NULL) {
	if (limitbuffer[0] != '#') {
	  switch(limititem) {
	  case 0: sscanf(limitbuffer,"%f %f %f",&ped_min_mean[0],&ped_max_mean[0],&ped_max_rms[0]); break;
	  case 1: sscanf(limitbuffer,"%f %f %f",&ped_min_mean[1],&ped_max_mean[1],&ped_max_rms[1]); break;
	  case 2: sscanf(limitbuffer,"%f %f %f",&ped_min_mean[2],&ped_max_mean[2],&ped_max_rms[2]); break;
	  case 3: sscanf(limitbuffer,"%f %f %f",&ped_min_mean[3],&ped_max_mean[3],&ped_max_rms[3]); break;
	  }
	  limititem++;
	}
      }
      fclose(flimits);
    }
  }
  TCanvas *c1 = new TCanvas("c1","Single cluster",600,600);
  char name[128];

  // PEDSUB & ZEROSUP PEAKS
  if ((filetype == 1) || (filetype == 2)) {


    sprintf(name, "hPeak0MeanAll");
    hPeak0MeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak0MeanAll) delete hPeak0MeanAll;
    hPeak0MeanAll = new TH1F(name, "",1024,-0.5,1023.5);
    hPeak0MeanAll->SetMinimum(0);
    sprintf(name, "hPeak0RmsAll");
    hPeak0RmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak0RmsAll) delete hPeak0RmsAll;
    hPeak0RmsAll = new TH1F(name, "",100,-0.5,99.5);
    hPeak0RmsAll->SetMinimum(0);

    sprintf(name, "hPeak1MeanAll");
    hPeak1MeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak1MeanAll) delete hPeak1MeanAll;
    hPeak1MeanAll = new TH1F(name, "",1024,-0.5,1023.5);
    hPeak1MeanAll->SetMinimum(0);
    sprintf(name, "hPeak1RmsAll");
    hPeak1RmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak1RmsAll) delete hPeak1RmsAll;
    hPeak1RmsAll = new TH1F(name, "",100,-0.5,99.5);
    hPeak1RmsAll->SetMinimum(0);

    sprintf(name, "hPeak2MeanAll");
    hPeak2MeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak2MeanAll) delete hPeak2MeanAll;
    hPeak2MeanAll = new TH1F(name, "",1024,-0.5,1023.5);
    hPeak2MeanAll->SetMinimum(0);
    sprintf(name, "hPeak2RmsAll");
    hPeak2RmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak2RmsAll) delete hPeak2RmsAll;
    hPeak2RmsAll = new TH1F(name, "",100,-0.5,99.5);
    hPeak2RmsAll->SetMinimum(0);


    sprintf(name, "hPeak0Mean");
    hPeak0Mean = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak0Mean) delete hPeak0Mean;
    hPeak0Mean = new TH1F(name, "",6000,0.0,6000.0);
    hPeak0Mean->SetMinimum(0);
    sprintf(name, "hPeak0Rms");
    hPeak0Rms = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak0Rms) delete hPeak0Rms;
    hPeak0Rms = new TH1F(name, "",6000,0.0,6000.0);
    hPeak0Rms->SetMinimum(0);
    
    sprintf(name, "hPeak1Mean");
    hPeak1Mean = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak1Mean) delete hPeak1Mean;
    hPeak1Mean = new TH1F(name, "",6000,0.0,6000.0);
    hPeak1Mean->SetMinimum(0);
    sprintf(name, "hPeak1Rms");
    hPeak1Rms = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak1Rms) delete hPeak1Rms;
    hPeak1Rms = new TH1F(name, "",6000,0.0,6000.0);
    hPeak1Rms->SetMinimum(0);
    
    sprintf(name, "hPeak2Mean");
    hPeak2Mean = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak2Mean) delete hPeak2Mean;
    hPeak2Mean = new TH1F(name, "",6000,0.0,6000.0);
    hPeak2Mean->SetMinimum(0);
    sprintf(name, "hPeak2Rms");
    hPeak2Rms = ((TH1F *)(gROOT->FindObject(name)));
    if (hPeak2Rms) delete hPeak2Rms;
    hPeak2Rms = new TH1F(name, "",6000,0.0,6000.0);
    hPeak2Rms->SetMinimum(0);
  }

  // PEDSUB PEDESTALS
  if (filetype == 1) {

    sprintf(name, "hPed0MeanAll");
    hPed0MeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0MeanAll) delete hPed0MeanAll;
    hPed0MeanAll = new TH1F(name, "",200,-0.5,199.5);
    hPed0MeanAll->SetMinimum(0);
    sprintf(name, "hPed0RmsAll");
    hPed0RmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0RmsAll) delete hPed0RmsAll;
    hPed0RmsAll = new TH1F(name, "",100,-0.5,99.5);
    hPed0RmsAll->SetMinimum(0);

    sprintf(name, "hPed1MeanAll");
    hPed1MeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed1MeanAll) delete hPed1MeanAll;
    hPed1MeanAll = new TH1F(name, "",200,-0.5,199.5);
    hPed1MeanAll->SetMinimum(0);
    sprintf(name, "hPed1RmsAll");
    hPed1RmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed1RmsAll) delete hPed1RmsAll;
    hPed1RmsAll = new TH1F(name, "",100,-0.5,99.5);
    hPed1RmsAll->SetMinimum(0);

    sprintf(name, "hPed2MeanAll");
    hPed2MeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed2MeanAll) delete hPed2MeanAll;
    hPed2MeanAll = new TH1F(name, "",200,-0.5,199.5);
    hPed2MeanAll->SetMinimum(0);
    sprintf(name, "hPed2RmsAll");
    hPed2RmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed2RmsAll) delete hPed2RmsAll;
    hPed2RmsAll = new TH1F(name, "",100,-0.5,99.5);
    hPed2RmsAll->SetMinimum(0);
    
    sprintf(name, "hPed0Mean");
    hPed0Mean = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0Mean) delete hPed0Mean;
    hPed0Mean = new TH1F(name, "",6000,0.0,6000);
    hPed0Mean->SetMinimum(0);
    sprintf(name, "hPed0Rms");
    hPed0Rms = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0Rms) delete hPed0Rms;
    hPed0Rms = new TH1F(name, "",6000,0.0,6000);
    hPed0Rms->SetMinimum(0);
    
    sprintf(name, "hPed1Mean");
    hPed1Mean = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed1Mean) delete hPed1Mean;
    hPed1Mean = new TH1F(name, "",6000,0.0,6000.0);
    hPed1Mean->SetMinimum(0);
    sprintf(name, "hPed1Rms");
    hPed1Rms = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed1Rms) delete hPed1Rms;
    hPed1Rms = new TH1F(name, "",6000,0.0,6000.0);
    hPed1Rms->SetMinimum(0);
    
    sprintf(name, "hPed2Mean");
    hPed2Mean = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed2Mean) delete hPed2Mean;
    hPed2Mean = new TH1F(name, "",6000,0.0,6000.0);
    hPed2Mean->SetMinimum(0);
    sprintf(name, "hPed2Rms");
    hPed2Rms = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed2Rms) delete hPed2Rms;
    hPed2Rms = new TH1F(name, "",6000,0.0,6000.0);
    hPed2Rms->SetMinimum(0);

    if (isshaperrun == 1) {
      sprintf(name, "hClLengthMean");
      hClLengthMean = ((TH1F *)(gROOT->FindObject(name)));
      if (hClLengthMean) delete hClLengthMean;
      hClLengthMean = new TH1F(name, "",6000,0.0,6000.0);
      hClLengthMean->SetMinimum(0);
      sprintf(name, "hClLengthRms");
      hClLengthRms = ((TH1F *)(gROOT->FindObject(name)));
      if (hClLengthRms) delete hClLengthRms;
      hClLengthRms = new TH1F(name, "",6000,0.0,6000.0);
      hClLengthRms->SetMinimum(0);
      sprintf(name, "hClLengthEntries");
      hClLengthEntries = ((TH1F *)(gROOT->FindObject(name)));
      if (hClLengthEntries) delete hClLengthEntries;
      hClLengthEntries = new TH1F(name, "",6000,0.0,6000.0);
      hClLengthEntries->SetMinimum(0);
      
      sprintf(name, "hClLengthMeanAll");
      hClLengthMeanAll = ((TH1F *)(gROOT->FindObject(name)));
      if (hClLengthMeanAll) delete hClLengthMeanAll;
      hClLengthMeanAll = new TH1F(name, "",200,0.0,100.0);
      hClLengthMeanAll->SetMinimum(0);
      sprintf(name, "hClLengthRmsAll");
      hClLengthRmsAll = ((TH1F *)(gROOT->FindObject(name)));
      if (hClLengthRmsAll) delete hClLengthRmsAll;
      hClLengthRmsAll = new TH1F(name, "",200,0.0,100.0);
      hClLengthRmsAll->SetMinimum(0);
      sprintf(name, "hClLengthEntriesAll");
      hClLengthEntriesAll = ((TH1F *)(gROOT->FindObject(name)));
      if (hClLengthEntriesAll) delete hClLengthEntriesAll;
      hClLengthEntriesAll = new TH1F(name, "",200,5900.0,6100.0);
      hClLengthEntriesAll->SetMinimum(0);
    }

  }

  // CLUSTERS ZEROSUP
  if (filetype == 2) {
    sprintf(name, "hClLengthMean");
    hClLengthMean = ((TH1F *)(gROOT->FindObject(name)));
    if (hClLengthMean) delete hClLengthMean;
    hClLengthMean = new TH1F(name, "",6000,0.0,6000.0);
    hClLengthMean->SetMinimum(0);
    sprintf(name, "hClLengthRms");
    hClLengthRms = ((TH1F *)(gROOT->FindObject(name)));
    if (hClLengthRms) delete hClLengthRms;
    hClLengthRms = new TH1F(name, "",6000,0.0,6000.0);
    hClLengthRms->SetMinimum(0);
    sprintf(name, "hClLengthEntries");
    hClLengthEntries = ((TH1F *)(gROOT->FindObject(name)));
    if (hClLengthEntries) delete hClLengthEntries;
    hClLengthEntries = new TH1F(name, "",6000,0.0,6000.0);
    hClLengthEntries->SetMinimum(0);
    
    sprintf(name, "hClLengthMeanAll");
    hClLengthMeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hClLengthMeanAll) delete hClLengthMeanAll;
    hClLengthMeanAll = new TH1F(name, "",200,0.0,100.0);
    hClLengthMeanAll->SetMinimum(0);
    sprintf(name, "hClLengthRmsAll");
    hClLengthRmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hClLengthRmsAll) delete hClLengthRmsAll;
    hClLengthRmsAll = new TH1F(name, "",200,0.0,100.0);
    hClLengthRmsAll->SetMinimum(0);
    sprintf(name, "hClLengthEntriesAll");
    hClLengthEntriesAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hClLengthEntriesAll) delete hClLengthEntriesAll;
    hClLengthEntriesAll = new TH1F(name, "",200,5900.0,6100.0);
    hClLengthEntriesAll->SetMinimum(0);
  }
  // PEDESTALS
  if (filetype == 3) {
    sprintf(name, "hPed0MeanAll");
    hPed0MeanAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0MeanAll) delete hPed0MeanAll;
    hPed0MeanAll = new TH1F(name, "",200,-0.5,199.5);
    hPed0MeanAll->SetMinimum(0);
    sprintf(name, "hPed0RmsAll");
    hPed0RmsAll = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0RmsAll) delete hPed0RmsAll;
    hPed0RmsAll = new TH1F(name, "",500,-0.5,49.5);
    hPed0RmsAll->SetMinimum(0);

    sprintf(name, "hPed0Mean");
    hPed0Mean = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0Mean) delete hPed0Mean;
    hPed0Mean = new TH1F(name, "",6000,0.0,6000.0);
    hPed0Mean->SetMinimum(0);
    sprintf(name, "hPed0Rms");
    hPed0Rms = ((TH1F *)(gROOT->FindObject(name)));
    if (hPed0Rms) delete hPed0Rms;
    hPed0Rms = new TH1F(name, "",6000,0.0,6000.0);
    hPed0Rms->SetMinimum(0);
  }
  
  int item = 0;
  char buffer[1024];
  int saltronb;
  int channel;
  float peak0mean;
  float peak0rms;
  float peak0entries;
  float peak1mean;
  float peak1rms;
  float peak1entries;
  float peak2mean;
  float peak2rms;
  float peak2entries;
  float ped0mean;
  float ped0rms;
  float ped0entries;
  float ped1mean;
  float ped1rms;
  float ped1entries;
  float ped2mean;
  float ped2rms;
  float ped2entries;
  float cllengthmean;
  float cllengthrms;
  int   cllengthentries;
  char therest[512];
  while (fgets(buffer,sizeof(buffer),fcsv) != NULL) {
    if (item != 0) {
      //     printf("%s",buffer);
      if (filetype == 1) {
	if (isshaperrun == 1) {
	  sscanf(buffer,"%d,%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%d,%s",
	       &saltronb,&channel,
	       &peak0mean,&peak0rms,&peak0entries,
	       &peak1mean,&peak1rms,&peak1entries,
	       &peak2mean,&peak2rms,&peak2entries,
	       &ped0mean,&ped0rms,&ped0entries,
	       &ped1mean,&ped1rms,&ped1entries,
	       &ped2mean,&ped2rms,&ped2entries,
	       &cllengthmean,&cllengthrms,&cllengthentries,
	       therest);
	}
	else {
	  sscanf(buffer,"%d,%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%s",
	       &saltronb,&channel,
	       &peak0mean,&peak0rms,&peak0entries,
	       &peak1mean,&peak1rms,&peak1entries,
	       &peak2mean,&peak2rms,&peak2entries,
	       &ped0mean,&ped0rms,&ped0entries,
	       &ped1mean,&ped1rms,&ped1entries,
	       &ped2mean,&ped2rms,&ped2entries,
	       therest);
	}
      }
      else if (filetype == 2) {
	sscanf(buffer,"%d,%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%d,%s",
	       &saltronb,&channel,
	       &peak0mean,&peak0rms,&peak0entries,
	       &peak1mean,&peak1rms,&peak1entries,
	       &peak2mean,&peak2rms,&peak2entries,
	       &cllengthmean,&cllengthrms,&cllengthentries,
	       therest);
      }
      else if (filetype == 3) {
 	sscanf(buffer,"%d,%d,%f,%f,%f,%s",
	       &saltronb,&channel,
	       &ped0mean,&ped0rms,&ped0entries,
	       therest);
      }
      if (saltronb != oldsaltronb) {
	chipnumbers[nbchips++] = saltronb;
	oldsaltronb = saltronb;
      }
      if ((filetype == 1) || (filetype == 2)) {
	if (peak0entries > 0) {
	  hPeak0MeanAll->Fill(peak0mean);
	  hPeak0RmsAll->Fill(peak0rms);
	}
	if (peak1entries > 0) {
	  hPeak1MeanAll->Fill(peak1mean);
	  hPeak1RmsAll->Fill(peak1rms);
	}
	if (peak2entries > 0) {
	  hPeak2MeanAll->Fill(peak2mean);
	  hPeak2RmsAll->Fill(peak2rms);
	}
	hPeak0Mean->SetBinContent(item,peak0mean);     
	hPeak0Rms->SetBinContent(item,peak0rms);      
	hPeak1Mean->SetBinContent(item,peak1mean);     
	hPeak1Rms->SetBinContent(item,peak1rms);
	hPeak2Mean->SetBinContent(item,peak2mean);     
	hPeak2Rms->SetBinContent(item,peak2rms);
	//	printf("PEAK %d %d %f %f %f %f %f %f\n",item,channel,peak0mean,peak0rms,peak1mean,peak1rms,peak2mean,peak2rms);
      }
      if (filetype == 1) {
	if (ped0entries > 0) {
	  hPed0MeanAll->Fill(ped0mean);
	  hPed0RmsAll->Fill(ped0rms);
	}
	if (ped1entries > 0) {
	  hPed1MeanAll->Fill(ped1mean);
	  hPed1RmsAll->Fill(ped1rms);
	}
	if (ped2entries > 0) {
	  hPed2MeanAll->Fill(ped2mean);
	  hPed2RmsAll->Fill(ped2rms);
	}
	hPed0Mean->SetBinContent(item,ped0mean);     
	hPed0Rms->SetBinContent(item,ped0rms);      
	hPed1Mean->SetBinContent(item,ped1mean);     
	hPed1Rms->SetBinContent(item,ped1rms);
	hPed2Mean->SetBinContent(item,ped2mean);     
	hPed2Rms->SetBinContent(item,ped2rms);

	if (isshaperrun == 1) {
	  hClLengthMean->SetBinContent(item,cllengthmean);     
	  hClLengthRms->SetBinContent(item,cllengthrms);
	  hClLengthEntries->SetBinContent(item,cllengthentries);
	  hClLengthMeanAll->Fill(cllengthmean);
	  hClLengthRmsAll->Fill(cllengthrms);
	  hClLengthEntries->Fill(cllengthentries);
	}
      }
      if (filetype == 2) {
	hClLengthMean->SetBinContent(item,cllengthmean);     
	hClLengthRms->SetBinContent(item,cllengthrms);
	hClLengthEntries->SetBinContent(item,cllengthentries);
	hClLengthMeanAll->Fill(cllengthmean);
	hClLengthRmsAll->Fill(cllengthrms);
	hClLengthEntries->Fill(cllengthentries);
      }
      if (filetype == 3) {
	hPed0MeanAll->Fill(ped0mean);
	hPed0RmsAll->Fill(ped0rms);
	hPed0Mean->SetBinContent(item,ped0mean);
	hPed0Rms->SetBinContent(item,ped0rms);
      }
    }
    item++;
  }
  fclose(fcsv);
  item--; // one comment line
  gStyle->SetOptStat(0);
  gStyle->Paint("-");
  int step=400;
  if ((filetype == 1) || (filetype == 2)) {
    char number[16];
    for (int j = 0, k = 0; j < item; j+=16,k++) {
      sprintf(number,"%d",chipnumbers[k]);
      hPeak0Mean->GetXaxis()->SetBinLabel(j+1,number);
      hPeak0Rms->GetXaxis()->SetBinLabel(j+1,number);
      hPeak1Mean->GetXaxis()->SetBinLabel(j+1,number);
      hPeak1Rms->GetXaxis()->SetBinLabel(j+1,number);
      hPeak2Mean->GetXaxis()->SetBinLabel(j+1,number);
      hPeak2Rms->GetXaxis()->SetBinLabel(j+1,number);
    }
    // PEAKTYPE 0
    sprintf(name, "Peaktype 0 mean");
    hPeak0Mean->SetTitle(name);
    hPeak0Mean->SetAxisRange(0,500, "Y");
    for (int j1 = 0; j1 < item; j1+=step) {
      hPeak0Mean->SetAxisRange(j1, j1+step, "X");
      hPeak0Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_min_mean[0],j1+step,peak_min_mean[0]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,peak_max_mean[0],j1+step,peak_max_mean[0]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      if (j1 == 0) sprintf(name,"%s.pdf(",filename);
      else sprintf(name,"%s.pdf",filename);
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Peaktype 0 rms");
    hPeak0Rms->SetTitle(name);
    hPeak0Rms->SetAxisRange(0,30, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      hPeak0Rms->SetAxisRange(j1, j1+step, "X");
      hPeak0Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_max_rms[0],j1+step,peak_max_rms[0]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    // PEAKTYPE1
    sprintf(name, "Peaktype 1 mean");
    hPeak1Mean->SetTitle(name);
    hPeak1Mean->SetAxisRange(0,1023, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=400) {
      hPeak1Mean->SetAxisRange(j1, j1+step, "X");
      hPeak1Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_min_mean[1],j1+step,peak_min_mean[1]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,peak_max_mean[1],j1+step,peak_max_mean[1]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Peaktype 1 rms");
    hPeak1Rms->SetTitle(name);
    hPeak1Rms->SetAxisRange(0,30, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      hPeak1Rms->SetAxisRange(j1, j1+step, "X");
      hPeak1Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_max_rms[1],j1+step,peak_max_rms[1]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }      
  }

  if (filetype == 1) {
    gStyle->SetOptStat(0);
    char number[16];
    for (int j = 0, k = 0; j < item; j+=16,k++) {
      sprintf(number,"%d",chipnumbers[k]);
      hPed0Mean->GetXaxis()->SetBinLabel(j+1,number);
      hPed0Rms->GetXaxis()->SetBinLabel(j+1,number);
      hPed1Mean->GetXaxis()->SetBinLabel(j+1,number);
      hPed1Rms->GetXaxis()->SetBinLabel(j+1,number);
      hPed2Mean->GetXaxis()->SetBinLabel(j+1,number);
      hPed2Rms->GetXaxis()->SetBinLabel(j+1,number);
    }
    // PEAKTYPE2
    sprintf(name, "Peaktype 2 mean");
    hPeak2Mean->SetTitle(name);
    hPeak2Mean->SetAxisRange(0,1023, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      hPeak2Mean->SetAxisRange(j1, j1+step, "X");
      hPeak2Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_min_mean[2],j1+step,peak_min_mean[2]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,peak_max_mean[2],j1+step,peak_max_mean[2]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Peaktype 2 rms");
    hPeak2Rms->SetTitle(name);
    hPeak2Rms->SetAxisRange(0,30, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=400) {
      hPeak2Rms->SetAxisRange(j1, j1+step, "X");
      hPeak2Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_max_rms[2],j1+step,peak_max_rms[2]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }      
    // PEDTYPE 0
    sprintf(name, "Pedtype 0 mean");
    hPed0Mean->SetTitle(name);    
    if (polarity == 1) hPed0Mean->SetAxisRange(0,500, "Y");
    else hPed0Mean->SetAxisRange(500,1000, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      hPed0Mean->SetAxisRange(j1,j1+step, "X");
      hPed0Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_min_mean[0],j1+step,ped_min_mean[0]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,ped_max_mean[0],j1+step,ped_max_mean[0]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Pedtype 0 rms");
    hPed0Rms->SetTitle(name);
    hPed0Rms->SetAxisRange(0,30, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      sprintf(name,"%s.pdf",filename);
      hPed0Rms->SetAxisRange(j1,j1+step, "X");
      hPed0Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_max_rms[0],j1+step,ped_max_rms[0]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    // PEDTYPE 1
    sprintf(name, "Pedtype 1 mean");
    hPed1Mean->SetTitle(name);    
    if (polarity == 1) hPed1Mean->SetAxisRange(0,500, "Y");
    else hPed1Mean->SetAxisRange(500,1000, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=400) {
      hPed1Mean->SetAxisRange(j1,j1+step, "X");
      hPed1Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_min_mean[1],j1+step,ped_min_mean[1]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,ped_max_mean[1],j1+step,ped_max_mean[1]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Pedtype 1 rms");
    hPed1Rms->SetTitle(name);
    hPed1Rms->SetAxisRange(0,30, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=400) {
      sprintf(name,"%s.pdf",filename);
      hPed1Rms->SetAxisRange(j1,j1+step, "X");
      hPed1Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_max_rms[1],j1+step,ped_max_rms[1]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    // PEDTYPE 2
    sprintf(name, "Pedtype 2 mean");
    hPed2Mean->SetTitle(name);    
    if (polarity == 1) hPed2Mean->SetAxisRange(0,500, "Y");
    else hPed2Mean->SetAxisRange(500,1000, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=400) {
      hPed2Mean->SetAxisRange(j1,j1+step, "X");
      hPed2Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_min_mean[2],j1+step,ped_min_mean[2]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,ped_max_mean[2],j1+step,ped_max_mean[2]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Pedtype 2 rms");
    hPed2Rms->SetTitle(name);
    hPed2Rms->SetAxisRange(0,30, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=400) {
      sprintf(name,"%s.pdf",filename);
      hPed2Rms->SetAxisRange(j1,j1+step, "X");
      hPed2Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_max_rms[2],j1+step,ped_max_rms[2]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    // SUMMARY PEAKTYPES
    gStyle->SetOptStat(111111);
    sprintf(name, "Peaktype 0 mean");
    hPeak0MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak0MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Peaktype 0 rms");
    hPeak0RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak0RmsAll->Draw();
    c1->SaveAs(name,"pdf");

    sprintf(name, "Peaktype 1 mean");
    hPeak1MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak1MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Peaktype 1 rms");
    hPeak1RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak1RmsAll->Draw();
    c1->SaveAs(name,"pdf");
    printf("FILE: %s\nPEAK1: %6.2f,%6.3f\n",filename,hPeak1MeanAll->GetMean(),hPeak1MeanAll->GetRMS());
    printf("LIMITS1: %6.2f %6.2f\n",
	   hPeak1MeanAll->GetMean() - 3.5*hPeak1MeanAll->GetRMS(),
	   hPeak1MeanAll->GetMean() + 3.5*hPeak1MeanAll->GetRMS());
    sprintf(name, "Peaktype 2 mean");
    hPeak2MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak2MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Peaktype 2 rms");
    hPeak2RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak2RmsAll->Draw();
    c1->SaveAs(name,"pdf");
    printf("PEAK2: %6.2f,%6.3f\n",hPeak2MeanAll->GetMean(),hPeak2MeanAll->GetRMS());
    printf("LIMITS2: %6.2f %6.2f\n",
	   hPeak2MeanAll->GetMean() - 3.5*hPeak2MeanAll->GetRMS(),
	   hPeak2MeanAll->GetMean() + 3.5*hPeak2MeanAll->GetRMS());
    
    // SUMMARY PEDTYPES
    gStyle->SetOptStat(111111);
    sprintf(name, "Pedtype 0 mean");
    hPed0MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPed0MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Pedtype 0 rms");
    hPed0RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPed0RmsAll->Draw();
    c1->SaveAs(name,"pdf");

    sprintf(name, "Pedtype 1 mean");
    hPed1MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPed1MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Pedtype 1 rms");
    hPed1RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPed1RmsAll->Draw();
    c1->SaveAs(name,"pdf");

    sprintf(name, "Pedtype 2 mean");
    hPed2MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPed2MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Pedtype 2 rms");
    hPed2RmsAll->SetTitle(name);
    if (isshaperrun == 0) {
      sprintf(name,"%s.pdf)",filename);
    }
    else {
      sprintf(name,"%s.pdf",filename);
    }
    hPed2RmsAll->Draw();
    c1->SaveAs(name,"pdf");

    if (isshaperrun == 1) {
      // CLUSTER LENGTHS
      gStyle->SetOptStat(0);
      sprintf(name, "Cluster length mean: g%1d-s%1d-p%1d-s%1d",gain,shaper,polarity,pgsource);
      hClLengthMean->SetTitle(name);
      hClLengthMean->SetAxisRange(0,200, "Y");
      sprintf(name,"%s.pdf",filename);
      char number[16];
      for (int j = 0, k = 0; j < item; j+=16,k++) {
	sprintf(number,"%d",chipnumbers[k]);
	hClLengthMean->GetXaxis()->SetBinLabel(j+1,number);
	hClLengthRms->GetXaxis()->SetBinLabel(j+1,number);
      }
      //    hClLengthMean->GetXaxis()->SetNdivisions(50);
      for (int j1 = 0; j1 < item; j1+=step) {
	hClLengthMean->SetAxisRange(j1, j1+step, "X");
	hClLengthMean->Draw();
	if (limititem != 0) {
	  TLine *line1 = new TLine(j1,cluster_min_mean,j1+step,cluster_min_mean);
	  line1->SetLineColor(kRed);
	  line1->Draw();
	  TLine *line2 = new TLine(j1,cluster_max_mean,j1+step,cluster_max_mean);
	  line2->SetLineColor(kRed);
	  line2->Draw();
	}
	c1->SaveAs(name,"pdf");
      }
      // CLUSTER RMS
      sprintf(name, "Cluster length rms: g%1d-s%1d-p%1d-s%1d",gain,shaper,polarity,pgsource);
      hClLengthRms->SetTitle(name);
      hClLengthRms->SetAxisRange(0,100, "Y");
      sprintf(name,"%s.pdf",filename);
      for (int j1 = 0; j1 < item; j1+=step) {
	hClLengthRms->SetAxisRange(j1, j1+step, "X");
	hClLengthRms->Draw();
	if (limititem != 0) {
	  TLine *line1 = new TLine(j1,cluster_max_rms,j1+step,cluster_max_rms);
	  line1->SetLineColor(kRed);
	  line1->Draw();
	}
	if ((j1+step) >= item) {
	  sprintf(name,"%s.pdf)",filename);
	}
	c1->SaveAs(name,"pdf");
      }
    }

  }
  else if (filetype == 2) {
    gStyle->SetOptStat(0);
   // PEAKTYPE2
    sprintf(name, "Peaktype 2 mean: g%1d-s%1d-p%1d",gain,shaper,polarity);
    hPeak2Mean->SetTitle(name);
    hPeak2Mean->SetAxisRange(0,1023, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      hPeak2Mean->SetAxisRange(j1, j1+step, "X");
      hPeak2Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_min_mean[2],j1+step,peak_min_mean[2]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,peak_max_mean[2],j1+step,peak_max_mean[2]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Peaktype 2 rms: g%1d-s%1d-p%1d",gain,shaper,polarity);
    hPeak2Rms->SetTitle(name);
    hPeak2Rms->SetAxisRange(0,30, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      hPeak2Rms->SetAxisRange(j1, j1+step, "X");
      hPeak2Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,peak_max_rms[2],j1+step,peak_max_rms[2]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }

    // SUMMARY PEAKTYPES
    gStyle->SetOptStat(111111);
    sprintf(name, "Peaktype 0 mean");
    hPeak0MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak0MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Peaktype 0 rms");
    hPeak0RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak0RmsAll->Draw();
    c1->SaveAs(name,"pdf");

    sprintf(name, "Peaktype 1 mean");
    hPeak1MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak1MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Peaktype 1 rms");
    hPeak1RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak1RmsAll->Draw();
    c1->SaveAs(name,"pdf");
    printf("FILE: %s\nPEAK1: %6.2f,%6.3f\n",filename,hPeak1MeanAll->GetMean(),hPeak1MeanAll->GetRMS());
    printf("LIMITS1: %6.2f %6.2f\n",
	   hPeak1MeanAll->GetMean() - 3.5*hPeak1MeanAll->GetRMS(),
	   hPeak1MeanAll->GetMean() + 3.5*hPeak1MeanAll->GetRMS());

    sprintf(name, "Peaktype 2 mean");
    hPeak2MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak2MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Peaktype 2 rms");
    hPeak2RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPeak2RmsAll->Draw();
    c1->SaveAs(name,"pdf");
    printf("PEAK2: %6.2f,%6.3f\n",hPeak2MeanAll->GetMean(),hPeak2MeanAll->GetRMS());
    printf("LIMITS2: %6.2f %6.2f\n",
	   hPeak2MeanAll->GetMean() - 3.5*hPeak2MeanAll->GetRMS(),
	   hPeak2MeanAll->GetMean() + 3.5*hPeak2MeanAll->GetRMS());

    // CLUSTER LENGTHS
    gStyle->SetOptStat(0);
    sprintf(name, "Cluster length mean: g%1d-s%1d-p%1d-s%1d",gain,shaper,polarity,pgsource);
    hClLengthMean->SetTitle(name);
    hClLengthMean->SetAxisRange(0,200, "Y");
    sprintf(name,"%s.pdf",filename);
    char number[16];
    for (int j = 0, k = 0; j < item; j+=16,k++) {
      sprintf(number,"%d",chipnumbers[k]);
      hClLengthMean->GetXaxis()->SetBinLabel(j+1,number);
      hClLengthRms->GetXaxis()->SetBinLabel(j+1,number);
    }
    //    hClLengthMean->GetXaxis()->SetNdivisions(50);
    for (int j1 = 0; j1 < item; j1+=step) {
      hClLengthMean->SetAxisRange(j1, j1+step, "X");
      hClLengthMean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,cluster_min_mean,j1+step,cluster_min_mean);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,cluster_max_mean,j1+step,cluster_max_mean);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    // CLUSTER RMS
    sprintf(name, "Cluster length rms: g%1d-s%1d-p%1d-s%1d",gain,shaper,polarity,pgsource);
    hClLengthRms->SetTitle(name);
    hClLengthRms->SetAxisRange(0,100, "Y");
    sprintf(name,"%s.pdf",filename);
    for (int j1 = 0; j1 < item; j1+=step) {
      hClLengthRms->SetAxisRange(j1, j1+step, "X");
      hClLengthRms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,cluster_max_rms,j1+step,cluster_max_rms);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      if ((j1+step) >= item) {
	sprintf(name,"%s.pdf)",filename);
      }
      c1->SaveAs(name,"pdf");
    }
  }
  // PEDESTALS RUN
  else if (filetype == 3) {
    // INIDVIDUAL CHANNELS
    gStyle->SetOptStat(0);
    sprintf(name, "Pedestals mean: g%1d-s%1d-p%1d",gain,shaper,polarity);
    hPed0Mean->SetAxisRange(0,500, "Y");
    hPed0Mean->SetTitle(name);    
    char number[16];
    for (int j = 0, k = 0; j < item; j+=16,k++) {
      sprintf(number,"%d",chipnumbers[k]);
      hPed0Mean->GetXaxis()->SetBinLabel(j+1,number);
      hPed0Rms->GetXaxis()->SetBinLabel(j+1,number);
    }
    for (int j1 = 0; j1 < item; j1+=step) {
      hPed0Mean->SetAxisRange(j1,j1+step, "X");
      hPed0Mean->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_min_mean[limitentry],j1+step,ped_min_mean[limitentry]);
	line1->SetLineColor(kRed);
	line1->Draw();
	TLine *line2 = new TLine(j1,ped_max_mean[limitentry],j1+step,ped_max_mean[limitentry]);
	line2->SetLineColor(kRed);
	line2->Draw();
      }
      if (j1 == 0) sprintf(name,"%s.pdf(",filename);
      else sprintf(name,"%s.pdf",filename);
      c1->SaveAs(name,"pdf");
    }
    sprintf(name, "Pedestals rms: g%1d-s%1d-p%1d",gain,shaper,polarity);
    hPed0Rms->SetTitle(name);
    hPed0Rms->SetAxisRange(0,30, "Y");
    for (int j1 = 0; j1 < item; j1+=step) {
      sprintf(name,"%s.pdf",filename);
      hPed0Rms->SetAxisRange(j1,j1+step, "X");
      hPed0Rms->Draw();
      if (limititem != 0) {
	TLine *line1 = new TLine(j1,ped_max_rms[limitentry],j1+step,ped_max_rms[limitentry]);
	line1->SetLineColor(kRed);
	line1->Draw();
      }
      c1->SaveAs(name,"pdf");
    }
    // SUMMARY
    gStyle->SetOptStat(111111);
    sprintf(name, "Pedestals mean: g%1d-s%1d-p%1d",gain,shaper,polarity);
    hPed0MeanAll->SetTitle(name);
    sprintf(name,"%s.pdf",filename);
    hPed0MeanAll->Draw();
    c1->SaveAs(name,"pdf");
    sprintf(name, "Pedestals rms: g%1d-s%1d-p%1d",gain,shaper,polarity);
    hPed0RmsAll->SetTitle(name);
    sprintf(name,"%s.pdf)",filename);
    hPed0RmsAll->Draw();
    c1->SaveAs(name,"pdf");
    printf("FILE: %s\nPED: %6.2f,%6.3f\n",filename,hPed0MeanAll->GetMean(),hPed0MeanAll->GetRMS());
    printf("LIMITS0: %6.2f %6.2f\n",
	   hPed0MeanAll->GetMean() - 3.0*hPed0MeanAll->GetRMS(),
	   hPed0MeanAll->GetMean() + 3.0*hPed0MeanAll->GetRMS());
    
  }
  printf("CHIPS: %d channels: %d\n",nbchips,item);
  return 0;  
}

int main (int argc, char *argv[])
{
  int iret = 0;
  if (argc != 2) {
    printf("Wrong number of arguments: argc = %d\nSyntax should be:\n./plotcsv.exe filename \n",argc);
    return 1;
  }
  iret = plotcsv(argv[1]);
  return iret;
}