MultivariateAnalysis/macros/network.C

#include "tmvaglob.C"

// this macro prints out a neural network generated by MethodMLP graphically
// @author: Matt Jachowski, jachowski@stanford.edu

// input: - Input file (result from TMVA),
//        - use of TMVA plotting TStyle
void network( TString fin = "TMVA.root", Bool_t useTMVAStyle = kTRUE )
{
   // set style and remove existing canvas'
   TMVAGlob::Initialize( useTMVAStyle );

   // checks if file with name "fin" is already open, and if not opens one
   TFile* file = TMVAGlob::OpenFile( fin );  

   TKey * mkey = TMVAGlob::FindMethod("MLP"); //(TDirectory*)gDirectory->Get("Method_MLP");
   if (mkey==0) {
      cout << "Could not locate directory MLP in file " << fin << endl;
      return;
   }
   TDirectory *dir = (TDirectory *)mkey->ReadObj();
   dir->cd();  
   TList titles;
   UInt_t ni = TMVAGlob::GetListOfTitles( dir, titles );
   if (ni==0) {
      cout << "No titles found for Method_MLP" << endl;
      return;
   }
   TIter nextTitle(&titles);
   TKey *titkey;
   TDirectory *titDir;
   while ((titkey = TMVAGlob::NextKey(nextTitle,"TDirectory"))) {
      titDir = (TDirectory *)titkey->ReadObj();
      cout << "Drawing title: " << titDir->GetName() << endl;
      draw_network(titDir);
   }
}

void draw_network(TDirectory* d)
{
   Bool_t __PRINT_LOGO__ = kTRUE;

   // create canvas
   TStyle *TMVAStyle = gROOT->GetStyle("Plain"); // our style is based on Plain
   TMVAStyle->SetCanvasColor(37 + 100);

   TCanvas* c = new TCanvas( "c", "Neural Network Layout", 100, 0, 1000, 650 );

   TIter next = d->GetListOfKeys();
   TKey *key;
   TString hName = "weights_hist";
   Int_t numHists = 0;

   // loop over all histograms with hName in name
   while (key = (TKey*)next()) {
      TClass *cl = gROOT->GetClass(key->GetClassName());
      if (!cl->InheritsFrom("TH2F")) continue;    
      TH2F *h = (TH2F*)key->ReadObj();    
      if (TString(h->GetName()).Contains( hName ))
         numHists++;
   }

   // loop over all histograms with hName in name again
   next.Reset();
   Double_t maxWeight = 0;

   // find max weight
   while (key = (TKey*)next()) {

      //cout << "Title: " << key->GetTitle() << endl;
      TClass *cl = gROOT->GetClass(key->GetClassName());
      if (!cl->InheritsFrom("TH2F")) continue;    

      TH2F* h = (TH2F*)key->ReadObj();    
      if (TString(h->GetName()).Contains( hName )){
 
         Int_t n1 = h->GetNbinsX();
         Int_t n2 = h->GetNbinsY();
         for (Int_t i = 0; i < n1; i++) {
            for (Int_t j = 0; j < n2; j++) {
               Double_t weight = TMath::Abs(h->GetBinContent(i+1, j+1));
               if (maxWeight < weight) maxWeight = weight;
            }
         }
      }
   }

   // draw network
   next.Reset();
   Int_t count = 0;
   while (key = (TKey*)next()) {

      TClass *cl = gROOT->GetClass(key->GetClassName());
      if (!cl->InheritsFrom("TH2F")) continue;    

      TH2F* h = (TH2F*)key->ReadObj();    
      if (TString(h->GetName()).Contains( hName )){
         draw_layer(c, h, count++, numHists+1, maxWeight);
      }
   }

   draw_layer_labels(numHists+1);

   // ============================================================
   if (__PRINT_LOGO__) TMVAGlob::plot_logo();
   // ============================================================  

   c->Update();

   TString fname = "plots/network";
   TMVAGlob::imgconv( c, fname );
}

void draw_layer_labels(Int_t nLayers)
{
   const Double_t LABEL_HEIGHT = 0.03;
   const Double_t LABEL_WIDTH  = 0.20;
   Double_t effWidth = 0.8*(1.0-LABEL_WIDTH)/nLayers;
   Double_t height = 0.8*LABEL_HEIGHT;
   Double_t margY = LABEL_HEIGHT - height;

   for (Int_t i = 0; i < nLayers; i++) {
      TString label = Form("Layer %i", i);
      Double_t cx = i*(1.0-LABEL_WIDTH)/nLayers+1.0/(2.0*nLayers)+LABEL_WIDTH;
      Double_t x1 = cx-0.8*effWidth/2.0;
      Double_t x2 = cx+0.8*effWidth/2.0;
      Double_t y1 = margY;
      Double_t y2 = margY + height;

      TPaveLabel *p = new TPaveLabel(x1, y1, x2, y2, label+"", "br");
      p->SetFillColor(gStyle->GetTitleFillColor());
      p->SetFillStyle(1001);
      p->Draw();
   }
}

void draw_input_labels(Int_t nInputs, Double_t* cy, 
                       Double_t rad, Double_t layerWidth)
{
   const Double_t LABEL_HEIGHT = 0.03;
   const Double_t LABEL_WIDTH  = 0.20;
   Double_t width = LABEL_WIDTH + (layerWidth-4*rad);
   Double_t margX = 0.01;
   Double_t effHeight = 0.8*LABEL_HEIGHT;

   TString *varNames = get_var_names(nInputs);
   TString input;

   for (Int_t i = 0; i < nInputs; i++) {
      if (i != nInputs-1) input = varNames[i];
      else                input = "bias";
      Double_t x1 = margX;
      Double_t x2 = margX + width;
      Double_t y1 = cy[i] - effHeight;
      Double_t y2 = cy[i] + effHeight;

      TPaveLabel *p = new TPaveLabel(x1, y1, x2, y2, input+"", "br");
      p->SetFillColor(gStyle->GetTitleFillColor());
      p->SetFillStyle(1001);
      p->Draw();
      if (i == nInputs-1) p->SetTextColor(9);
   }

   delete[] varNames;
}

TString* get_var_names(Int_t nVars)
{
   TString fname = "weights/MVAnalysis_MLP.weights.txt";
   ifstream fin( fname );
   if (!fin.good( )) { // file not found --> Error
      cout << "Error opening " << fname << endl;
      exit(1);
   }

   Int_t   idummy;
   Float_t fdummy;
   TString dummy = "";

   // file header with name
   while (!dummy.Contains("#VAR")) fin >> dummy;
   fin >> dummy >> dummy >> dummy; // the rest of header line

   // number of variables
   fin >> dummy >> idummy;
   // at this point, we should have idummy == nVars

   // variable mins and maxes
   TString* vars = new TString[nVars];
   for (Int_t i = 0; i < idummy; i++) fin >> vars[i] >> dummy >> dummy >> dummy;

   fin.close();

   return vars;
}

void draw_activation(TCanvas* c, Double_t cx, Double_t cy, 
                     Double_t radx, Double_t rady, Int_t whichActivation)
{
   TImage *activation = NULL;

   switch (whichActivation) {
   case 0:
      activation = TImage::Open("sigmoid-small.png");
      break;
   case 1:
      activation = TImage::Open("line-small.png");
      break;
   default:
      cout << "Activation index " << whichActivation << " is not known." << endl;
      cout << "You messed up or you need to modify network.C to introduce a new "
           << "activation function (and image) corresponding to this index" << endl;
   }

   if (activation == NULL) {
      cout << "Could not create an image... exit" << endl;
      return;
   }
  
   activation->SetConstRatio(kFALSE);

   radx *= 0.7;
   rady *= 0.7;
   TString name = Form("activation%f%f", cx, cy);
   TPad* p = new TPad(name+"", name+"", cx-radx, cy-rady, cx+radx, cy+rady);

   p->Draw();
   p->cd();

   activation->Draw();
   c->cd();
}

void draw_layer(TCanvas* c, TH2F* h, Int_t iHist, 
                Int_t nLayers, Double_t maxWeight)
{
   const Double_t MAX_NEURONS_NICE = 12;
   const Double_t LABEL_HEIGHT = 0.03;
   const Double_t LABEL_WIDTH  = 0.20;
   Double_t ratio = ((Double_t)(c->GetWindowHeight())) / c->GetWindowWidth();
   Double_t rad, cx1, *cy1, cx2, *cy2;

   // this is the smallest radius that will still display the activation images
   rad = 0.04*650/c->GetWindowHeight();

   Int_t nNeurons1 = h->GetNbinsX();
   cx1 = iHist*(1.0-LABEL_WIDTH)/nLayers + 1.0/(2.0*nLayers) + LABEL_WIDTH;
   cy1 = new Double_t[nNeurons1];

   Int_t nNeurons2 = h->GetNbinsY();
   cx2 = (iHist+1)*(1.0-LABEL_WIDTH)/nLayers + 1.0/(2.0*nLayers) + LABEL_WIDTH;
   cy2 = new Double_t[nNeurons2];

   Double_t effRad1 = rad;
   if (nNeurons1 > MAX_NEURONS_NICE)
      effRad1 = 0.8*(1.0-LABEL_HEIGHT)/(2.0*nNeurons1);


   for (Int_t i = 0; i < nNeurons1; i++) {
      cy1[nNeurons1-i-1] = i*(1.0-LABEL_HEIGHT)/nNeurons1 + 
         1.0/(2.0*nNeurons1) + LABEL_HEIGHT;

      if (iHist == 0) {

         TEllipse *ellipse 
            = new TEllipse(cx1, cy1[nNeurons1-i-1], 
                           effRad1*ratio, effRad1, 0, 360, 0);
         ellipse->SetFillColor(19+150);
         ellipse->SetFillStyle(1001);
         ellipse->Draw();

         if (i == 0) ellipse->SetLineColor(9);

         if (nNeurons1 > MAX_NEURONS_NICE) continue;

         Int_t whichActivation = 0;
         if (iHist==0 || iHist==nLayers-1 || i==0) whichActivation = 1;
         draw_activation(c, cx1, cy1[nNeurons1-i-1], 
                         rad*ratio, rad, whichActivation);
      }
   }

   if (iHist == 0) draw_input_labels(nNeurons1, cy1, rad, (1.0-LABEL_WIDTH)/nLayers);

   Double_t effRad2 = rad;
   if (nNeurons2 > MAX_NEURONS_NICE)
      effRad2 = 0.8*(1.0-LABEL_HEIGHT)/(2.0*nNeurons2);

   for (Int_t i = 0; i < nNeurons2; i++) {
      cy2[nNeurons2-i-1] = i*(1.0-LABEL_HEIGHT)/nNeurons2 + 1.0/(2.0*nNeurons2) + LABEL_HEIGHT;

      TEllipse *ellipse = 
         new TEllipse(cx2, cy2[nNeurons2-i-1], effRad2*ratio, effRad2, 0, 360, 0);
      ellipse->SetFillColor(19+150);
      ellipse->SetFillStyle(1001);
      ellipse->Draw();

      if (i == 0 && nNeurons2 > 1) ellipse->SetLineColor(9);

      if (nNeurons2 > MAX_NEURONS_NICE) continue;

      Int_t whichActivation = 0;
      if (iHist+1==0 || iHist+1==nLayers-1 || i==0) whichActivation = 1;
      draw_activation(c, cx2, cy2[nNeurons2-i-1], rad*ratio, rad, whichActivation);
   }

   for (Int_t i = 0; i < nNeurons1; i++) {
      for (Int_t j = 0; j < nNeurons2; j++) {
         draw_synapse(cx1, cy1[i], cx2, cy2[j], effRad1*ratio, effRad2*ratio,
                      h->GetBinContent(i+1, j+1)/maxWeight);
      }
   }

   delete[] cy1;
   delete[] cy2;
}

void draw_synapse(Double_t cx1, Double_t cy1, Double_t cx2, Double_t cy2,
                  Double_t  rad1, Double_t rad2, Double_t weightNormed)
{
   const Double_t TIP_SIZE   = 0.01;
   const Double_t MAX_WEIGHT = 8;
   const Double_t MAX_COLOR  = 100;  // red
   const Double_t MIN_COLOR  = 60;   // blue

   if (weightNormed == 0) return;

   //   gStyle->SetPalette(100, NULL);

   TArrow *arrow = new TArrow(cx1+rad1, cy1, cx2-rad2, cy2, TIP_SIZE, ">");
   arrow->SetFillColor(1);
   arrow->SetFillStyle(1001);
   arrow->SetLineWidth((Int_t)(TMath::Abs(weightNormed)*MAX_WEIGHT+0.5));
   arrow->SetLineColor((Int_t)((weightNormed+1.0)/2.0*(MAX_COLOR-MIN_COLOR)+MIN_COLOR+0.5));
   arrow->Draw();
}
Revision:	1.1
Committed:	Thu Nov 20 22:34:50 2008 UTC (16 years, 5 months ago) by kukartse
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V00-03-01, ZMorph_BASE_20100408, gak040610_morphing, V00-02-02, gak011410, gak010310, ejterm2010_25nov2009, V00-02-01, V00-02-00, gak112409, CMSSW_22X_branch_base, segala101609, V00-01-15, V00-01-14, V00-01-13, V00-01-12, V00-01-11, V00-01-10, gak031009, gak030509, gak022309, gak021209, gak040209, gak012809, V00-01-09, V00-01-08, V00-01-07, V00-01-06, V00-01-05, V00-01-04, V00-00-07, V00-00-06, V00-00-05, V00-00-04, V00-01-03, V00-00-02, V00-00-01, HEAD
Branch point for:	ZMorph-V00-03-01, CMSSW_22X_branch
Log Message:	created /macros with TMVA scripts in it
#	User	Rev	Content
1	kukartse	1.1	#include "tmvaglob.C"
2
3			// this macro prints out a neural network generated by MethodMLP graphically
4			// @author: Matt Jachowski, jachowski@stanford.edu
5
6			// input: - Input file (result from TMVA),
7			// - use of TMVA plotting TStyle
8			void network( TString fin = "TMVA.root", Bool_t useTMVAStyle = kTRUE )
9			{
10			// set style and remove existing canvas'
11			TMVAGlob::Initialize( useTMVAStyle );
12
13			// checks if file with name "fin" is already open, and if not opens one
14			TFile* file = TMVAGlob::OpenFile( fin );
15
16			TKey * mkey = TMVAGlob::FindMethod("MLP"); //(TDirectory*)gDirectory->Get("Method_MLP");
17			if (mkey==0) {
18			cout << "Could not locate directory MLP in file " << fin << endl;
19			return;
20			}
21			TDirectory dir = (TDirectory )mkey->ReadObj();
22			dir->cd();
23			TList titles;
24			UInt_t ni = TMVAGlob::GetListOfTitles( dir, titles );
25			if (ni==0) {
26			cout << "No titles found for Method_MLP" << endl;
27			return;
28			}
29			TIter nextTitle(&titles);
30			TKey *titkey;
31			TDirectory *titDir;
32			while ((titkey = TMVAGlob::NextKey(nextTitle,"TDirectory"))) {
33			titDir = (TDirectory *)titkey->ReadObj();
34			cout << "Drawing title: " << titDir->GetName() << endl;
35			draw_network(titDir);
36			}
37			}
38
39			void draw_network(TDirectory* d)
40			{
41			Bool_t __PRINT_LOGO__ = kTRUE;
42
43			// create canvas
44			TStyle *TMVAStyle = gROOT->GetStyle("Plain"); // our style is based on Plain
45			TMVAStyle->SetCanvasColor(37 + 100);
46
47			TCanvas* c = new TCanvas( "c", "Neural Network Layout", 100, 0, 1000, 650 );
48
49			TIter next = d->GetListOfKeys();
50			TKey *key;
51			TString hName = "weights_hist";
52			Int_t numHists = 0;
53
54			// loop over all histograms with hName in name
55			while (key = (TKey*)next()) {
56			TClass *cl = gROOT->GetClass(key->GetClassName());
57			if (!cl->InheritsFrom("TH2F")) continue;
58			TH2F h = (TH2F)key->ReadObj();
59			if (TString(h->GetName()).Contains( hName ))
60			numHists++;
61			}
62
63			// loop over all histograms with hName in name again
64			next.Reset();
65			Double_t maxWeight = 0;
66
67			// find max weight
68			while (key = (TKey*)next()) {
69
70			//cout << "Title: " << key->GetTitle() << endl;
71			TClass *cl = gROOT->GetClass(key->GetClassName());
72			if (!cl->InheritsFrom("TH2F")) continue;
73
74			TH2F* h = (TH2F*)key->ReadObj();
75			if (TString(h->GetName()).Contains( hName )){
76
77			Int_t n1 = h->GetNbinsX();
78			Int_t n2 = h->GetNbinsY();
79			for (Int_t i = 0; i < n1; i++) {
80			for (Int_t j = 0; j < n2; j++) {
81			Double_t weight = TMath::Abs(h->GetBinContent(i+1, j+1));
82			if (maxWeight < weight) maxWeight = weight;
83			}
84			}
85			}
86			}
87
88			// draw network
89			next.Reset();
90			Int_t count = 0;
91			while (key = (TKey*)next()) {
92
93			TClass *cl = gROOT->GetClass(key->GetClassName());
94			if (!cl->InheritsFrom("TH2F")) continue;
95
96			TH2F* h = (TH2F*)key->ReadObj();
97			if (TString(h->GetName()).Contains( hName )){
98			draw_layer(c, h, count++, numHists+1, maxWeight);
99			}
100			}
101
102			draw_layer_labels(numHists+1);
103
104			// ============================================================
105			if (__PRINT_LOGO__) TMVAGlob::plot_logo();
106			// ============================================================
107
108			c->Update();
109
110			TString fname = "plots/network";
111			TMVAGlob::imgconv( c, fname );
112			}
113
114			void draw_layer_labels(Int_t nLayers)
115			{
116			const Double_t LABEL_HEIGHT = 0.03;
117			const Double_t LABEL_WIDTH = 0.20;
118			Double_t effWidth = 0.8*(1.0-LABEL_WIDTH)/nLayers;
119			Double_t height = 0.8*LABEL_HEIGHT;
120			Double_t margY = LABEL_HEIGHT - height;
121
122			for (Int_t i = 0; i < nLayers; i++) {
123			TString label = Form("Layer %i", i);
124			Double_t cx = i(1.0-LABEL_WIDTH)/nLayers+1.0/(2.0nLayers)+LABEL_WIDTH;
125			Double_t x1 = cx-0.8*effWidth/2.0;
126			Double_t x2 = cx+0.8*effWidth/2.0;
127			Double_t y1 = margY;
128			Double_t y2 = margY + height;
129
130			TPaveLabel *p = new TPaveLabel(x1, y1, x2, y2, label+"", "br");
131			p->SetFillColor(gStyle->GetTitleFillColor());
132			p->SetFillStyle(1001);
133			p->Draw();
134			}
135			}
136
137			void draw_input_labels(Int_t nInputs, Double_t* cy,
138			Double_t rad, Double_t layerWidth)
139			{
140			const Double_t LABEL_HEIGHT = 0.03;
141			const Double_t LABEL_WIDTH = 0.20;
142			Double_t width = LABEL_WIDTH + (layerWidth-4*rad);
143			Double_t margX = 0.01;
144			Double_t effHeight = 0.8*LABEL_HEIGHT;
145
146			TString *varNames = get_var_names(nInputs);
147			TString input;
148
149			for (Int_t i = 0; i < nInputs; i++) {
150			if (i != nInputs-1) input = varNames[i];
151			else input = "bias";
152			Double_t x1 = margX;
153			Double_t x2 = margX + width;
154			Double_t y1 = cy[i] - effHeight;
155			Double_t y2 = cy[i] + effHeight;
156
157			TPaveLabel *p = new TPaveLabel(x1, y1, x2, y2, input+"", "br");
158			p->SetFillColor(gStyle->GetTitleFillColor());
159			p->SetFillStyle(1001);
160			p->Draw();
161			if (i == nInputs-1) p->SetTextColor(9);
162			}
163
164			delete[] varNames;
165			}
166
167			TString* get_var_names(Int_t nVars)
168			{
169			TString fname = "weights/MVAnalysis_MLP.weights.txt";
170			ifstream fin( fname );
171			if (!fin.good( )) { // file not found --> Error
172			cout << "Error opening " << fname << endl;
173			exit(1);
174			}
175
176			Int_t idummy;
177			Float_t fdummy;
178			TString dummy = "";
179
180			// file header with name
181			while (!dummy.Contains("#VAR")) fin >> dummy;
182			fin >> dummy >> dummy >> dummy; // the rest of header line
183
184			// number of variables
185			fin >> dummy >> idummy;
186			// at this point, we should have idummy == nVars
187
188			// variable mins and maxes
189			TString* vars = new TString[nVars];
190			for (Int_t i = 0; i < idummy; i++) fin >> vars[i] >> dummy >> dummy >> dummy;
191
192			fin.close();
193
194			return vars;
195			}
196
197			void draw_activation(TCanvas* c, Double_t cx, Double_t cy,
198			Double_t radx, Double_t rady, Int_t whichActivation)
199			{
200			TImage *activation = NULL;
201
202			switch (whichActivation) {
203			case 0:
204			activation = TImage::Open("sigmoid-small.png");
205			break;
206			case 1:
207			activation = TImage::Open("line-small.png");
208			break;
209			default:
210			cout << "Activation index " << whichActivation << " is not known." << endl;
211			cout << "You messed up or you need to modify network.C to introduce a new "
212			<< "activation function (and image) corresponding to this index" << endl;
213			}
214
215			if (activation == NULL) {
216			cout << "Could not create an image... exit" << endl;
217			return;
218			}
219
220			activation->SetConstRatio(kFALSE);
221
222			radx *= 0.7;
223			rady *= 0.7;
224			TString name = Form("activation%f%f", cx, cy);
225			TPad* p = new TPad(name+"", name+"", cx-radx, cy-rady, cx+radx, cy+rady);
226
227			p->Draw();
228			p->cd();
229
230			activation->Draw();
231			c->cd();
232			}
233
234			void draw_layer(TCanvas* c, TH2F* h, Int_t iHist,
235			Int_t nLayers, Double_t maxWeight)
236			{
237			const Double_t MAX_NEURONS_NICE = 12;
238			const Double_t LABEL_HEIGHT = 0.03;
239			const Double_t LABEL_WIDTH = 0.20;
240			Double_t ratio = ((Double_t)(c->GetWindowHeight())) / c->GetWindowWidth();
241			Double_t rad, cx1, cy1, cx2, cy2;
242
243			// this is the smallest radius that will still display the activation images
244			rad = 0.04*650/c->GetWindowHeight();
245
246			Int_t nNeurons1 = h->GetNbinsX();
247			cx1 = iHist(1.0-LABEL_WIDTH)/nLayers + 1.0/(2.0nLayers) + LABEL_WIDTH;
248			cy1 = new Double_t[nNeurons1];
249
250			Int_t nNeurons2 = h->GetNbinsY();
251			cx2 = (iHist+1)(1.0-LABEL_WIDTH)/nLayers + 1.0/(2.0nLayers) + LABEL_WIDTH;
252			cy2 = new Double_t[nNeurons2];
253
254			Double_t effRad1 = rad;
255			if (nNeurons1 > MAX_NEURONS_NICE)
256			effRad1 = 0.8(1.0-LABEL_HEIGHT)/(2.0nNeurons1);
257
258
259			for (Int_t i = 0; i < nNeurons1; i++) {
260			cy1[nNeurons1-i-1] = i*(1.0-LABEL_HEIGHT)/nNeurons1 +
261			1.0/(2.0*nNeurons1) + LABEL_HEIGHT;
262
263			if (iHist == 0) {
264
265			TEllipse *ellipse
266			= new TEllipse(cx1, cy1[nNeurons1-i-1],
267			effRad1*ratio, effRad1, 0, 360, 0);
268			ellipse->SetFillColor(19+150);
269			ellipse->SetFillStyle(1001);
270			ellipse->Draw();
271
272			if (i == 0) ellipse->SetLineColor(9);
273
274			if (nNeurons1 > MAX_NEURONS_NICE) continue;
275
276			Int_t whichActivation = 0;
277			if (iHist==0 \|\| iHist==nLayers-1 \|\| i==0) whichActivation = 1;
278			draw_activation(c, cx1, cy1[nNeurons1-i-1],
279			rad*ratio, rad, whichActivation);
280			}
281			}
282
283			if (iHist == 0) draw_input_labels(nNeurons1, cy1, rad, (1.0-LABEL_WIDTH)/nLayers);
284
285			Double_t effRad2 = rad;
286			if (nNeurons2 > MAX_NEURONS_NICE)
287			effRad2 = 0.8(1.0-LABEL_HEIGHT)/(2.0nNeurons2);
288
289			for (Int_t i = 0; i < nNeurons2; i++) {
290			cy2[nNeurons2-i-1] = i(1.0-LABEL_HEIGHT)/nNeurons2 + 1.0/(2.0nNeurons2) + LABEL_HEIGHT;
291
292			TEllipse *ellipse =
293			new TEllipse(cx2, cy2[nNeurons2-i-1], effRad2*ratio, effRad2, 0, 360, 0);
294			ellipse->SetFillColor(19+150);
295			ellipse->SetFillStyle(1001);
296			ellipse->Draw();
297
298			if (i == 0 && nNeurons2 > 1) ellipse->SetLineColor(9);
299
300			if (nNeurons2 > MAX_NEURONS_NICE) continue;
301
302			Int_t whichActivation = 0;
303			if (iHist+1==0 \|\| iHist+1==nLayers-1 \|\| i==0) whichActivation = 1;
304			draw_activation(c, cx2, cy2[nNeurons2-i-1], rad*ratio, rad, whichActivation);
305			}
306
307			for (Int_t i = 0; i < nNeurons1; i++) {
308			for (Int_t j = 0; j < nNeurons2; j++) {
309			draw_synapse(cx1, cy1[i], cx2, cy2[j], effRad1ratio, effRad2ratio,
310			h->GetBinContent(i+1, j+1)/maxWeight);
311			}
312			}
313
314			delete[] cy1;
315			delete[] cy2;
316			}
317
318			void draw_synapse(Double_t cx1, Double_t cy1, Double_t cx2, Double_t cy2,
319			Double_t rad1, Double_t rad2, Double_t weightNormed)
320			{
321			const Double_t TIP_SIZE = 0.01;
322			const Double_t MAX_WEIGHT = 8;
323			const Double_t MAX_COLOR = 100; // red
324			const Double_t MIN_COLOR = 60; // blue
325
326			if (weightNormed == 0) return;
327
328			// gStyle->SetPalette(100, NULL);
329
330			TArrow *arrow = new TArrow(cx1+rad1, cy1, cx2-rad2, cy2, TIP_SIZE, ">");
331			arrow->SetFillColor(1);
332			arrow->SetFillStyle(1001);
333			arrow->SetLineWidth((Int_t)(TMath::Abs(weightNormed)*MAX_WEIGHT+0.5));
334			arrow->SetLineColor((Int_t)((weightNormed+1.0)/2.0*(MAX_COLOR-MIN_COLOR)+MIN_COLOR+0.5));
335			arrow->Draw();
336			}