package cnslab.cnsnetwork;
import java.io.*;
import java.util.*;
import jpvm.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import cnslab.cnsmath.*;
import edu.jhu.mb.ernst.model.ModelFactory;
import edu.jhu.mb.ernst.model.Synapse;
import edu.jhu.mb.ernst.model.MutableSynapse;
/***********************************************************************
* Organize layers of neurons.
*
* @version
* $Date: 2012-08-04 20:43:22 +0200 (Sat, 04 Aug 2012) $
* $Rev: 104 $
* $Author: croft $
* @author
* Yi Dong
* @author
* David Wallace Croft
***********************************************************************/
public final class LayerStructure
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
{
private static final Class<LayerStructure>
CLASS = LayerStructure.class;
private static final Logger
LOGGER = LoggerFactory.getLogger ( CLASS );
//
public static final int
LINEMAP = 0,
ABMAP = 1;
public static int
sectionsInAxisX, // previously named A
sectionsInAxisY; // previously named B
//
public Map<String, Integer> prefixSuffixToLayerIndexMap;
/** for slow cellmap */
public Map<String, Integer> indexmap;
/** Remove maps after setup core!!! */
@Deprecated
public String [ ] celltype;
@Deprecated
public Map<String, TreeSet<Synapse>> [ ] branchmaps;
/** Scaffold is used to help to build up the network structure,
which should be private */
public Map<Integer, Map<String, SizeID>> scaffold;
public Map<Integer, Axon> axons;
public List<Layer> layerList;
public int
edgeLengthX,
edgeLengthY;
public int
numberOfNeurons;
/** end index in neuron for each node; .length=number parallel nodes */
public int [ ]
nodeEndIndices;
private int
nodeCount; // formerly named nodeNumber
/** holds reference to neuron array after sent to network */
public Neuron [ ]
neurons;
public int
base,
neuron_end,
back_idum2,
back_iy;
public int [ ]
back_iv = new int [ 32 ];
public int
backseed;
public Seed
idum;
public int
numSYN;
// private final instance variables
private final ModelFactory modelFactory;
////////////////////////////////////////////////////////////////////////
// constructor methods
////////////////////////////////////////////////////////////////////////
public LayerStructure (
final ModelFactory modelFactory,
final int nodeCount,
final int edgeLengthX,
final int edgeLengthY )
////////////////////////////////////////////////////////////////////////
{
this.modelFactory = modelFactory;
numSYN = 0;
base = 0;
// cellmap=new TreeMap<String, Integer>();
prefixSuffixToLayerIndexMap = new TreeMap<String, Integer> ( );
indexmap = new TreeMap<String, Integer> ( );
layerList = new LinkedList<Layer> ( );
this.edgeLengthX = edgeLengthX;
this.edgeLengthY = edgeLengthY;
this.nodeCount = nodeCount;
//numberOfNeurons=nodeIndices[nodeIndices.length-1] + 1;
//nodeEndIndices=nodeIndices;
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/***********************************************************************
* set up the base neuron index for NetHost hostId
***********************************************************************/
public void neuronIndex ( final int hostId )
////////////////////////////////////////////////////////////////////////
{
neuron_end = nodeEndIndices [ hostId ];
base = 0;
if ( hostId != 0 )
{
base = nodeEndIndices [ hostId - 1 ] + 1;
}
}
/***********************************************************************
* Add one layer of neurons into the structure.
*
* @param pre
* @param suf
* @param mult
* @param type
***********************************************************************/
public void addLayer (
final String pre,
final String suf,
final int mult,
final String type )
////////////////////////////////////////////////////////////////////////
{
final int xMul = mult;
final int yMul = mult;
if ( mult == 0 )
{
throw new RuntimeException ( "No zero multiplier is allowed" );
}
if( xMul < 0 )
{
if ( edgeLengthX % xMul != 0 )
{
throw new RuntimeException (
xMul + "is not a multiplier of x-edge length" + edgeLengthX );
}
}
if ( yMul < 0 )
{
if ( edgeLengthY % yMul != 0 )
{
throw new RuntimeException (
yMul + "is not a multiplier of y-edge length" + edgeLengthY );
}
}
final Layer tmp_layer = new Layer ( pre, suf, mult, type );
layerList.add ( tmp_layer );
prefixSuffixToLayerIndexMap.put (
pre + "," + suf,
Integer.valueOf ( layerList.size ( ) - 1 ) );
}
public void addLayer (
final String pre,
final String suf,
final int xmult,
final int ymult,
final String type )
////////////////////////////////////////////////////////////////////////
{
final int xMul = xmult;
final int yMul = ymult;
if ( xmult == 0 )
{
throw new RuntimeException ( "No zero multiplier is allowed" );
}
if ( xMul < 0 )
{
if ( edgeLengthX % xMul != 0 )
{
throw new RuntimeException (
xMul + "is not a multiplier of x-edge length" + edgeLengthX );
}
}
if( yMul < 0 )
{
if ( edgeLengthY % yMul !=0 )
{
throw new RuntimeException (
yMul + "is not a multiplier of y-edge length" + edgeLengthY );
}
}
final Layer tmp_layer = new Layer ( pre, suf, xmult, ymult, type );
layerList.add ( tmp_layer );
prefixSuffixToLayerIndexMap.put (
pre + "," + suf,
Integer.valueOf ( layerList.size ( ) - 1 ) );
}
/***********************************************************************
* Map the cells in linear fashion.
***********************************************************************/
public void mapcells ( )
////////////////////////////////////////////////////////////////////////
{
int
xstep,
ystep,
xresosize,
yresosize;
numberOfNeurons = totalNumNeurons ( );
nodeEndIndices = new int [ nodeCount ];
// celltype = new String [ numberOfNeurons ];
int n_neuron = 0;
// String str;
final int layerListSize = layerList.size ( );
for ( int layerIndex = 0; layerIndex < layerListSize; layerIndex++ )
{
final Layer layer = layerList.get ( layerIndex );
final int layerMultiplierX = layer.getMultiplierX ( );
if ( layerMultiplierX > 0 )
{
xstep = 1;
xresosize = layerMultiplierX * edgeLengthX;
}
else
{
xstep = -layerMultiplierX;
xresosize = edgeLengthX;
}
final int layerMultiplierY = layer.getMultiplierY ( );
if ( layerMultiplierY > 0 )
{
ystep = 1;
yresosize = layerMultiplierY * edgeLengthY;
}
else
{
ystep = -layerMultiplierY;
yresosize = edgeLengthY;
}
for ( int x = 0; x < xresosize; x += xstep )
{
for ( int y = 0; y < yresosize; y += ystep )
{
// str=(layer_structure.get(iter2)).getPrefix()+"," + iter
// + "," + iter1 + ","+(layer_structure.get(iter2)).getSuffix();
// celltype[n_neuron]= new String(str);
// cellmap.put(str,n_neuron);
n_neuron++;
}
}
}
if ( n_neuron != numberOfNeurons )
{
throw new RuntimeException (
"number doesn't match" + n_neuron + " - " + numberOfNeurons );
}
for ( int i = 0; i < nodeCount; i++ )
{
nodeEndIndices [ i ] = numberOfNeurons / nodeCount * ( i + 1 );
if ( i == nodeCount - 1 )
{
nodeEndIndices [ i ] = numberOfNeurons - 1;
}
}
// branchmaps=new TreeMap[numberOfNeurons];
// for(int a=0;a<numberOfNeurons;a++)
// branchmaps[a]=new TreeMap<String, TreeSet<Synapse>>();
}
@Deprecated
public void qmapcells()
////////////////////////////////////////////////////////////////////////
{
boolean sqCheck=false;
int sect;
for(sect=0;sect<10;sect++)
{
if(nodeCount == sect*sect)
{
sqCheck=true;
break;
}
}
if(!sqCheck)
{
throw new RuntimeException (
"Now only sqaure nodeNubmers are supported" );
}
nodeEndIndices = new int[nodeCount];
int iter,iter1,iter2,n_neuron;
int xstep,ystep,xresosize,yresosize;
int xOri,yOri;
int hostId=0;
numberOfNeurons = totalNumNeurons() ;
// celltype=new String[numberOfNeurons];
n_neuron=0;
String str;
for(int secX=0;secX<sect;secX++) // x axis section
{
for(int secY=0;secY<sect;secY++) //y axis section
{
// go through all layers
for(iter2=0;iter2<layerList.size();iter2++)
{
if((layerList.get(iter2)).getMultiplierX()>0)
{
xstep=1;
if(secX!=0)
{
xOri=(layerList.get(iter2)).getMultiplierX()
*edgeLengthX/sect*(secX);
}
else
{
xOri=0;
}
if(secX!=sect-1)
{
xresosize=(layerList.get(iter2)).getMultiplierX()
*edgeLengthX/sect*(secX+1);
}
else
{
xresosize=(layerList.get(iter2)).getMultiplierX()
*edgeLengthX;
}
}
else
{
xstep=-((layerList.get(iter2)).getMultiplierX());
if(secX!=0)
{
xOri=edgeLengthX/sect*(secX);
xOri=xOri + xOri % xstep;
}
else
{
xOri=0;
}
if(secX!=sect-1)
{
xresosize=edgeLengthX/sect*(secX+1);
}
else
{
xresosize=edgeLengthX;
}
}
if((layerList.get(iter2)).getMultiplierY()>0)
{
ystep=1;
if(secY!=0)
{
yOri=(layerList.get(iter2)).getMultiplierY()
*edgeLengthY/sect*(secY);
}
else
{
yOri=0;
}
if(secY!=sect-1)
{
yresosize=(layerList.get(iter2)).getMultiplierY()
*edgeLengthY/sect*(secY+1);
}
else
{
yresosize=(layerList.get(iter2)).getMultiplierY()
*edgeLengthY;
}
}
else
{
ystep=-((layerList.get(iter2)).getMultiplierY());
if(secY!=0)
{
yOri=edgeLengthY/sect*(secY);
yOri=yOri + yOri % ystep;
}
else
{
yOri=0;
}
if(secY!=sect-1)
{
yresosize=edgeLengthY/sect*(secY+1);
}
else
{
yresosize=edgeLengthY;
}
}
for(iter=xOri;iter<xresosize;iter+=xstep)
{
for(iter1=yOri;iter1<yresosize;iter1+=ystep)
{
// System.out.println( "x"+iter+" y"+iter1+" layer"+iter2
// +" host"+(secX*sect+secY));
str=(layerList.get(iter2)).getPrefix() + ","+iter
+ "," + iter1 +","
+ (layerList.get(iter2)).getSuffix();
// celltype[n_neuron]= new String(str);
// cellmap.put(str,n_neuron);
n_neuron++;
}
}
} // END: for layer iteration
nodeEndIndices[hostId]=n_neuron-1;
hostId++;
}
}
if(n_neuron!=numberOfNeurons)
{
throw new RuntimeException(
"number doesn't match"+n_neuron+" - "+numberOfNeurons);
}
// branchmaps=new TreeMap[numberOfNeurons];
// for(int a=0;a<numberOfNeurons;a++)
// branchmaps[a]=new TreeMap<String, TreeSet<Synapse>>();
}
/***********************************************************************
* Used in main Host, which is fast and used only to get numbers.
* neurons are not really initialized to save memory
*
* @param a sections in x axis
* @param b sections in y axis
***********************************************************************/
public void abmapcells_Main (
final int a,
final int b )
////////////////////////////////////////////////////////////////////////
{
if ( a * b != nodeCount )
{
throw new RuntimeException (
"a times b should equal to " + nodeCount );
}
sectionsInAxisX = a;
sectionsInAxisY = b;
nodeEndIndices = new int [ nodeCount ];
int iter, iter1, n_neuron;
int xstep, ystep, xresosize, yresosize;
int xOri, yOri;
int hostId = 0;
numberOfNeurons = totalNumNeurons ( );
// celltype=new String[numberOfNeurons];
n_neuron = 0;
String str;
// System.out.println(a+" "+b);
for ( int secX = 0; secX < a; secX++ ) // x axis section
{
for ( int secY = 0; secY < b; secY++ ) // y axis section
{
// go through all layers
final int layerListSize = layerList.size ( );
for (
int layerIndex = 0; layerIndex < layerListSize; layerIndex++ )
{
final Layer layer = layerList.get ( layerIndex );
final int layerMultiplierX = layer.getMultiplierX ( );
if ( layerMultiplierX > 0 )
{
xstep = 1;
if ( secX != 0 )
{
xOri= ( int ) ( ( double ) layerMultiplierX
* ( double ) edgeLengthX / ( double ) a
* ( double ) ( secX ) );
}
else
{
xOri = 0;
}
if ( secX != a - 1 )
{
xresosize= ( int ) ( ( double ) layerMultiplierX
* ( double ) edgeLengthX / ( double ) a
* ( double ) ( secX + 1 ) );
}
else
{
xresosize = layerMultiplierX * edgeLengthX;
}
}
else
{
xstep = -layerMultiplierX;
if ( secX != 0 )
{
xOri = ( int ) ( ( double ) edgeLengthX
/ ( double ) a * ( double ) ( secX ) );
xOri = xOri + xstep - xOri % xstep;
}
else
{
xOri = 0;
}
if ( secX != a - 1 )
{
xresosize = ( int ) ( ( double ) edgeLengthX
/ ( double ) a * ( double ) ( secX + 1 ) );
xresosize = xresosize + xstep - xresosize % xstep;
if ( xresosize > edgeLengthX )
{
xresosize = edgeLengthX;
}
}
else
{
xresosize = edgeLengthX;
}
}
final int layerMultiplierY = layer.getMultiplierY ( );
if ( layerMultiplierY > 0 )
{
ystep = 1;
if ( secY != 0 )
{
yOri = ( int ) ( ( double ) layerMultiplierY
* ( double ) edgeLengthY / ( double ) b
* ( double ) ( secY ) );
}
else
{
yOri = 0;
}
if ( secY != b - 1 )
{
yresosize = ( int ) ( ( double ) layerMultiplierY
* ( double ) edgeLengthY / ( double ) b
* ( double ) ( secY + 1 ) );
}
else
{
yresosize = layerMultiplierY * edgeLengthY;
}
}
else
{
ystep = -layer.getMultiplierY ( );
if ( secY != 0 )
{
yOri = ( int ) ( ( double ) edgeLengthY
/ ( double ) b * ( double ) ( secY ) );
yOri = yOri + ystep - yOri % ystep;
}
else
{
yOri = 0;
}
if ( secY != b - 1 )
{
yresosize = ( int ) ( ( double ) edgeLengthY / ( double ) b
* ( double ) ( secY + 1 ) );
yresosize = yresosize + ystep - yresosize % ystep;
if ( yresosize > edgeLengthY )
{
yresosize = edgeLengthY;
}
}
else
{
yresosize = edgeLengthY;
}
}
indexmap.put (
secX + "," + secY + "," + layerIndex,
n_neuron);
for ( iter = xOri; iter < xresosize; iter += xstep )
{
for ( iter1 = yOri; iter1 < yresosize; iter1 += ystep )
{
// System.out.println("x"+iter+" y"+iter1+" layer"+iter2
// +" host"+(secX*b+secY));
str = layer.getPrefix ( ) + ","+ iter + "," + iter1 + ","
+ layer.getSuffix ( );
// celltype[n_neuron]= new String(str);
// cellmap.put(str,n_neuron);
n_neuron++;
}
}
} // END: for layer iteration
nodeEndIndices [ hostId ] = n_neuron - 1;
hostId++;
} // END: for y axis
} // END: for x axis
if ( n_neuron != numberOfNeurons )
{
throw new RuntimeException (
"number doesn't match" + n_neuron + " - " + numberOfNeurons );
}
// branchmaps=new TreeMap[numberOfNeurons];
// for(int i=0;i<numberOfNeurons;i++)
// branchmaps[i]=new TreeMap<String, TreeSet<Synapse>>();
LOGGER.trace ( "Total Neuron:" + numberOfNeurons );
}
/***********************************************************************
* Calculates the neuron index from the layer x,y coordinates.
***********************************************************************/
@Deprecated
public int cellmap_slow (
final String pre,
final String suf,
final int x,
final int y )
////////////////////////////////////////////////////////////////////////
{
int
stepX = 0,
stepY = 0,
xresosize = 0,
yresosize = 0;
int
xOri = 0,
yOri = 0;
boolean
foundX = false,
foundY = false;
int layerIndex;
try
{
layerIndex = prefixSuffixToLayerIndexMap.get ( pre + "," + suf );
}
catch ( final Exception e )
{
//TODO: Add Exception handler here
throw new RuntimeException ( "pre" + pre + " suf" + suf );
}
final Layer layer = layerList.get ( layerIndex );
final int
layerMultiplierX = layer.getMultiplierX ( ),
layerMultiplierY = layer.getMultiplierY ( );
final double
neuronsPerSectionX
= ( layerMultiplierX * edgeLengthX ) / ( double ) sectionsInAxisX,
neuronsPerSectionY
= ( layerMultiplierY * edgeLengthY ) / ( double ) sectionsInAxisY;
int secX;
for ( secX = 0; secX < sectionsInAxisX; secX++ )
{
if ( layerMultiplierX > 0 )
{
stepX = 1;
if ( secX != 0 )
{
// TODO: maybe multiply first and then divide
xOri = ( int ) ( neuronsPerSectionX * secX );
}
else
{
xOri = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
xresosize = ( int ) ( neuronsPerSectionX * ( secX + 1 ) );
}
else
{
xresosize = layerMultiplierX * edgeLengthX;
}
}
else
{
stepX = -layerMultiplierX;
if ( secX != 0 )
{
xOri = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX ) );
xOri = xOri + stepX - xOri % stepX;
}
else
{
xOri = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
xresosize = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX + 1 ) );
xresosize = xresosize + stepX - xresosize % stepX;
if ( xresosize > edgeLengthX )
{
xresosize=edgeLengthX;
}
}
else
{
xresosize = edgeLengthX;
}
}
if ( x >= xOri
&& x < xresosize )
{
foundX = true;
break;
}
}
int secY;
for ( secY = 0; secY < sectionsInAxisY; secY++ )
{
if ( layerMultiplierY > 0 )
{
stepY = 1;
if ( secY != 0 )
{
yOri = ( int ) ( neuronsPerSectionY * secY );
}
else
{
yOri = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
yresosize = ( int ) ( neuronsPerSectionY * ( secY + 1 ) );
}
else
{
yresosize = layerMultiplierY * edgeLengthY;
}
}
else
{
stepY = -layerMultiplierY;
if ( secY != 0 )
{
yOri = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY ) );
yOri = yOri + stepY - yOri % stepY;
}
else
{
yOri = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
yresosize = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY + 1 ) );
yresosize = yresosize + stepY - yresosize % stepY;
if ( yresosize > edgeLengthY )
{
yresosize = edgeLengthY;
}
}
else
{
yresosize = edgeLengthY;
}
}
if( y >= yOri
&& y < yresosize )
{
foundY = true;
break;
}
} // END: for y axis sections
if ( foundX
&& foundY )
{
int
n_neuron = indexmap.get ( secX + "," + secY + "," + layerIndex );
// int xall = 0;
int yall = 0;
// for(iter=xOri;iter<xresosize;iter+=xstep) xall++;
for ( int indexY = yOri; indexY < yresosize; indexY += stepY )
{
yall++;
}
n_neuron = n_neuron + yall * ( x - xOri ) / stepX;
n_neuron = n_neuron + ( y - yOri ) / stepY;
if ( ( x - xOri ) % stepX != 0
|| ( y - yOri ) % stepY != 0 )
{
return -1;
}
return n_neuron;
/*
for(iter=xOri;iter<xresosize;iter+=xstep)
{
for(iter1=yOri;iter1<yresosize;iter1+=ystep)
{
if(x==iter && y==iter1)return n_neuron;
n_neuron++;
}
}
*/
}
else
{
throw new RuntimeException (
"neuron was not found in cellmap_slow"
+ " pre:" + pre + "suf:" + suf + "x:" + x + "y:" + y );
}
// throw new RuntimeException("neuron was not found in cellmap_slow");
}
@Deprecated
public boolean celllayer_test(int index,String pre, String suf) // a sections in x axis , b sections in y axis;
////////////////////////////////////////////////////////////////////////
{
int iter,iter1,iter2,n_neuron;
int xstep=0,ystep=0,xresosize=0,yresosize=0;
int xOri=0,yOri=0;
int hostId=0;
int secX,secY;
boolean xfound=false,yfound=false;
n_neuron=0;
String str;
//iter2=layermap.get(pre+","+suf);
//Iterator<Integer> iter = indexmap.entrySet(
// indexmap.put(secX+","+secY+","+iter2,n_neuron);
int bsecX=-1,bsecY=-1,bindex=-1;
boolean exit=false;
for(secX=0;secX<sectionsInAxisX;secX++)
{
for(secY=0;secY<sectionsInAxisX;secY++) // x axis section
{
for(iter2 = 0 ; iter2< prefixSuffixToLayerIndexMap.size(); iter2++)
{
if(index>=indexmap.get(secX+","+secY+","+iter2))
{
bsecX=secX;
bsecY=secY;
bindex=iter2;
}
if(index<indexmap.get(secX+","+secY+","+iter2))
{
exit=true;
break;
}
}
if(exit)break;
}
if(exit)break;
}
iter2=bindex;
return (layerList.get(iter2).getPrefix().equals(pre) && layerList.get(iter2).getSuffix().equals(suf));
}
@Deprecated
public int [] celllayer_cordinate(int index,String pre, String suf)
////////////////////////////////////////////////////////////////////////
{
int iter,iter1,iter2,n_neuron;
int xstep=0,ystep=0,xresosize=0,yresosize=0;
int xOri=0,yOri=0;
int hostId=0;
int secX,secY;
boolean xfound=false,yfound=false;
n_neuron=0;
String str;
//iter2=layermap.get(pre+","+suf);
//Iterator<Integer> iter = indexmap.entrySet(
// indexmap.put(secX+","+secY+","+iter2,n_neuron);
int bsecX=-1,bsecY=-1,bindex=-1;
boolean exit=false;
// iter2 = layermap.get(pre+","+suf);
for(secX=0;secX<sectionsInAxisX;secX++)
{
for(secY=0;secY<sectionsInAxisX;secY++) // x axis section
{
for(iter2 = 0 ; iter2< prefixSuffixToLayerIndexMap.size(); iter2++)
{
if(index>=indexmap.get(secX+","+secY+","+iter2))
{
bsecX=secX;
bsecY=secY;
bindex=iter2;
}
if(index<indexmap.get(secX+","+secY+","+iter2))
{
exit=true;
break;
}
}
if(exit)break;
}
if(exit)break;
}
iter2=bindex;
for(secX=0;secX<sectionsInAxisX;secX++) // x axis section
{
if((layerList.get(iter2)).getMultiplierX()>0)
{
xstep=1;
if(secX!=0)
{
xOri=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize=(layerList.get(iter2)).getMultiplierX()*edgeLengthX;
}
}
else
{
xstep=-((layerList.get(iter2)).getMultiplierX());
if(secX!=0)
{
xOri=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri=xOri + xstep - xOri %xstep;
}
else
{
xOri=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize=xresosize + xstep - xresosize % xstep;
if(xresosize>edgeLengthX)xresosize=edgeLengthX;
}
else
{
xresosize=edgeLengthX;
}
}
}
for(secY=0;secY<sectionsInAxisY;secY++) //y axis section
{
if((layerList.get(iter2)).getMultiplierY()>0)
{
ystep=1;
if(secY!=0)
{
yOri=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize=(layerList.get(iter2)).getMultiplierY()*edgeLengthY;
}
}
else
{
ystep=-((layerList.get(iter2)).getMultiplierY());
if(secY!=0)
{
yOri=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri=yOri + ystep - yOri % ystep;
}
else
{
yOri=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize=yresosize + ystep - yresosize % ystep;
if(yresosize>edgeLengthY)yresosize=edgeLengthY;
}
else
{
yresosize=edgeLengthY;
}
}
} // END: for y axis sections
secX=bsecX;
secY=bsecY;
// iter2=bindex;
// try {
n_neuron = indexmap.get(secX+","+secY+","+iter2);
// }
// catch(Exception ex) {
// throw new RuntimeException("secX"+secX+" secY"+secY+", iter2"+iter2+" indexmap"+indexmap.size()+" layermap:"+layermap.size()+" pre:"+pre+" suf:"+suf);
// }
int yall = 0;
// for(iter=xOri;iter<xresosize;iter+=xstep) xall++;
for(iter1=yOri;iter1<yresosize;iter1+=ystep) yall++;
int x = (index - n_neuron)/yall*xstep + xOri;
int y = ((index - n_neuron)%(yall))*ystep + yOri;
int [] out = new int [] {x,y};
return out;
}
/***********************************************************************
* Give the nethost id, map the cells in a times b, slow method.
*
* @param a parts in X dimension
* @param b parts in X dimension
* @param host_id
***********************************************************************/
@Deprecated
public String celltype_slow(int index) // a sections in x axis , b sections in y axis;
////////////////////////////////////////////////////////////////////////
{
int iter,iter1,iter2,n_neuron;
int xstep=0,ystep=0,xresosize=0,yresosize=0;
int xOri=0,yOri=0;
int hostId=0;
int secX,secY;
boolean xfound=false,yfound=false;
n_neuron=0;
String str;
//iter2=layermap.get(pre+","+suf);
//Iterator<Integer> iter = indexmap.entrySet(
// indexmap.put(secX+","+secY+","+iter2,n_neuron);
int bsecX=-1,bsecY=-1,bindex=-1;
boolean exit=false;
for(secX=0;secX<sectionsInAxisX;secX++)
{
for(secY=0;secY<sectionsInAxisX;secY++) // x axis section
{
for(iter2 = 0 ; iter2< prefixSuffixToLayerIndexMap.size(); iter2++)
{
if(index>=indexmap.get(secX+","+secY+","+iter2))
{
bsecX=secX;
bsecY=secY;
bindex=iter2;
}
if(index<indexmap.get(secX+","+secY+","+iter2))
{
exit=true;
break;
}
}
if(exit)break;
}
if(exit)break;
}
iter2=bindex;
for(secX=0;secX<sectionsInAxisX;secX++) // x axis section
{
if((layerList.get(iter2)).getMultiplierX()>0)
{
xstep=1;
if(secX!=0)
{
xOri=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize=(layerList.get(iter2)).getMultiplierX()*edgeLengthX;
}
}
else
{
xstep=-((layerList.get(iter2)).getMultiplierX());
if(secX!=0)
{
xOri=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri=xOri + xstep - xOri %xstep;
}
else
{
xOri=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize=xresosize + xstep - xresosize % xstep;
if(xresosize>edgeLengthX)xresosize=edgeLengthX;
}
else
{
xresosize=edgeLengthX;
}
}
}
for(secY=0;secY<sectionsInAxisY;secY++) //y axis section
{
if((layerList.get(iter2)).getMultiplierY()>0)
{
ystep=1;
if(secY!=0)
{
yOri=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize=(layerList.get(iter2)).getMultiplierY()*edgeLengthY;
}
}
else
{
ystep=-((layerList.get(iter2)).getMultiplierY());
if(secY!=0)
{
yOri=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri=yOri + ystep - yOri % ystep;
}
else
{
yOri=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize=yresosize + ystep - yresosize % ystep;
if(yresosize>edgeLengthY)yresosize=edgeLengthY;
}
else
{
yresosize=edgeLengthY;
}
}
} // END: for y axis sections
secX=bsecX;
secY=bsecY;
iter2=bindex;
n_neuron = indexmap.get(secX+","+secY+","+iter2);
int yall = 0;
// for(iter=xOri;iter<xresosize;iter+=xstep) xall++;
for(iter1=yOri;iter1<yresosize;iter1+=ystep) yall++;
int x = (index - n_neuron)/yall*xstep + xOri;
int y = ((index - n_neuron)%(yall))*ystep + yOri;
return layerList.get(iter2).getPrefix()+","+x+","+y+","+layerList.get(iter2).getSuffix();
}
/***********************************************************************
* Give the nethost id, map the cells in a times b, fast method.
*
* @param a parts in X dimension
* @param b parts in X dimension
* @param host_id
***********************************************************************/
public void abmapcells (
final int a,
final int b,
final int host_id ) // a sections in x axis , b sections in y axis;
////////////////////////////////////////////////////////////////////////
{
if ( a * b != nodeCount )
{
throw new RuntimeException (
"a times b should equal to " + nodeCount );
}
sectionsInAxisX = a;
sectionsInAxisY = b;
nodeEndIndices = new int[nodeCount];
int iter,iter1,iter2,n_neuron;
int xstep,ystep,xresosize,yresosize;
int xOri,yOri;
int hostId=0;
numberOfNeurons = totalNumNeurons() ;
// celltype=new String[numberOfNeurons];
int hostCell=0;
n_neuron=0;
String str;
int cc=0;
// System.out.println(a+" "+b);
for(int secX=0;secX<a;secX++) // x axis section
{
for(int secY=0;secY<b;secY++) //y axis section
{
for(iter2=0;iter2<layerList.size();iter2++) // go through all layers
{
if((layerList.get(iter2)).getMultiplierX()>0)
{
xstep=1;
if(secX!=0)
{
xOri=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)a*(double)(secX));
}
else
{
xOri=0;
}
if(secX!=a-1)
{
xresosize=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)a*(double)(secX+1));
}
else
{
xresosize=(layerList.get(iter2)).getMultiplierX()*edgeLengthX;
}
}
else
{
xstep=-((layerList.get(iter2)).getMultiplierX());
if(secX!=0)
{
xOri=(int)((double)edgeLengthX/(double)a*(double)(secX));
xOri=xOri + xstep - xOri %xstep;
}
else
{
xOri=0;
}
if(secX!=a-1)
{
xresosize=(int)((double)edgeLengthX/(double)a*(double)(secX+1));
xresosize=xresosize + xstep - xresosize % xstep;
if(xresosize>edgeLengthX)xresosize=edgeLengthX;
}
else
{
xresosize=edgeLengthX;
}
}
if((layerList.get(iter2)).getMultiplierY()>0)
{
ystep=1;
if(secY!=0)
{
yOri=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)b*(double)(secY));
}
else
{
yOri=0;
}
if(secY!=b-1)
{
yresosize=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)b*(double)(secY+1));
}
else
{
yresosize=(layerList.get(iter2)).getMultiplierY()*edgeLengthY;
}
}
else
{
ystep=-((layerList.get(iter2)).getMultiplierY());
if(secY!=0)
{
yOri=(int)((double)edgeLengthY/(double)b*(double)(secY));
yOri=yOri + ystep - yOri % ystep;
}
else
{
yOri=0;
}
if(secY!=b-1)
{
yresosize=(int)((double)edgeLengthY/(double)b*(double)(secY+1));
yresosize=yresosize + ystep - yresosize % ystep;
if(yresosize>edgeLengthY)yresosize=edgeLengthY;
}
else
{
yresosize=edgeLengthY;
}
}
indexmap.put(secX+","+secY+","+iter2,n_neuron);
for(iter=xOri;iter<xresosize;iter+=xstep)
{
for(iter1=yOri;iter1<yresosize;iter1+=ystep)
{
// System.out.println("x"+iter+" y"+iter1+" layer"+iter2+" host"+(secX*b+secY));
if(hostId == host_id)
{
hostCell++;
}
// celltype[n_neuron]= new String(str);
// cellmap.put(str,n_neuron);
n_neuron++;
}
}
} // END: for layer iteration
nodeEndIndices[hostId]=n_neuron-1;
hostId++;
} // END: for y axis
} // END: for x axis
hostId=0;
celltype = new String[hostCell];
for(int secX=0;secX<a;secX++) // x axis section
{
for(int secY=0;secY<b;secY++) //y axis section
{
for(iter2=0;iter2<layerList.size();iter2++) // go through all layers
{
if((layerList.get(iter2)).getMultiplierX()>0)
{
xstep=1;
if(secX!=0)
{
xOri=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)a*(double)(secX));
}
else
{
xOri=0;
}
if(secX!=a-1)
{
xresosize=(int)((double)(layerList.get(iter2)).getMultiplierX()*(double)edgeLengthX/(double)a*(double)(secX+1));
}
else
{
xresosize=(layerList.get(iter2)).getMultiplierX()*edgeLengthX;
}
}
else
{
xstep=-((layerList.get(iter2)).getMultiplierX());
if(secX!=0)
{
xOri=(int)((double)edgeLengthX/(double)a*(double)(secX));
xOri=xOri + xstep - xOri %xstep;
}
else
{
xOri=0;
}
if(secX!=a-1)
{
xresosize=(int)((double)edgeLengthX/(double)a*(double)(secX+1));
xresosize=xresosize + xstep - xresosize % xstep;
if(xresosize>edgeLengthX)xresosize=edgeLengthX;
}
else
{
xresosize=edgeLengthX;
}
}
if((layerList.get(iter2)).getMultiplierY()>0)
{
ystep=1;
if(secY!=0)
{
yOri=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)b*(double)(secY));
}
else
{
yOri=0;
}
if(secY!=b-1)
{
yresosize=(int)((double)(layerList.get(iter2)).getMultiplierY()*(double)edgeLengthY/(double)b*(double)(secY+1));
}
else
{
yresosize=(layerList.get(iter2)).getMultiplierY()*edgeLengthY;
}
}
else
{
ystep=-((layerList.get(iter2)).getMultiplierY());
if(secY!=0)
{
yOri=(int)((double)edgeLengthY/(double)b*(double)(secY));
yOri=yOri + ystep - yOri % ystep;
}
else
{
yOri=0;
}
if(secY!=b-1)
{
yresosize=(int)((double)edgeLengthY/(double)b*(double)(secY+1));
yresosize=yresosize + ystep - yresosize % ystep;
if(yresosize>edgeLengthY)yresosize=edgeLengthY;
}
else
{
yresosize=edgeLengthY;
}
}
for(iter=xOri;iter<xresosize;iter+=xstep)
{
for(iter1=yOri;iter1<yresosize;iter1+=ystep)
{
if(hostId == host_id)
{
str = (layerList.get(iter2)).getPrefix() +","+ iter + "," + iter1 +","+ (layerList.get(iter2)).getSuffix();
celltype[cc] = new String(str);
cc++;
hostCell++;
}
}
}
} // END: for layer iteration
hostId++;
} // END: for y axis
}
if(n_neuron!=numberOfNeurons) throw new RuntimeException("number doesn't match"+n_neuron+" - "+numberOfNeurons);
// branchmaps=new TreeMap[numberOfNeurons];
// for(int i=0;i<numberOfNeurons;i++)
// branchmaps[i]=new TreeMap<String, TreeSet<Synapse>>();
scaffold = new HashMap<Integer, Map<String, SizeID> >();
/*
for(int i=0;i<numberOfNeurons;i++)
{
scaffold[i]=new TreeMap<String, SizeID>();
}
*/
// axons = new Axon[numberOfNeurons];
}
/***********************************************************************
* Compute the total number of neurons
*
* @return number of neurons
***********************************************************************/
public int totalNumNeurons ( )
////////////////////////////////////////////////////////////////////////
{
int num = 0;
int xMul, yMul;
for ( final Layer layer : layerList )
{
xMul = layer.getMultiplierX ( );
yMul = layer.getMultiplierY ( );
if ( xMul < 0 )
{
if ( edgeLengthX % xMul != 0 )
{
throw new RuntimeException (
xMul + "is not a multiplier of x-edge length" + edgeLengthX );
}
}
if ( yMul < 0 )
{
if ( edgeLengthY % yMul !=0 )
{
throw new RuntimeException (
yMul + "is not a multiplier of y-edge length" + edgeLengthY );
}
}
num += ( xMul > 0 ? edgeLengthX * xMul : edgeLengthX / -xMul )
* ( yMul > 0 ? edgeLengthY * yMul : edgeLengthY / -yMul );
}
return num;
}
/***********************************************************************
* Find out the number of neurons of a layer, given the layer name
*
* @param prefix string
* @param suffix string
* @return number of neurons
***********************************************************************/
public int layerNumNeurons (
final String prefix,
final String suffix )
////////////////////////////////////////////////////////////////////////
{
final int
index = prefixSuffixToLayerIndexMap.get ( prefix + "," + suffix );
// while(!( layer_structure.get(iter)).getPrefix().equals(prefix)
// || !( layer_structure.get(iter)).getSuffix().equals(suffix))
// {
// iter++;
// }
final Layer layer = layerList.get ( index );
final int
xMultiplier = layer.getMultiplierX ( ),
yMultiplier = layer.getMultiplierY ( );
int
xstep,
ystep,
xresosize,
yresosize;
if ( xMultiplier > 0
&& yMultiplier > 0 )
{
xstep = 1;
ystep = 1;
xresosize = xMultiplier * edgeLengthX;
yresosize = yMultiplier * edgeLengthY;
}
else if ( xMultiplier > 0
&& yMultiplier < 0 )
{
xstep = 1;
ystep = -yMultiplier;
xresosize = xMultiplier * edgeLengthX;
yresosize = edgeLengthY;
}
else if ( xMultiplier < 0
&& yMultiplier > 0 )
{
xstep = -xMultiplier;
ystep = 1;
xresosize = edgeLengthX;
yresosize = yMultiplier * edgeLengthY;
}
else
{
xstep = -xMultiplier;
ystep = -yMultiplier;
xresosize = edgeLengthX;
yresosize = edgeLengthY;
}
return xresosize * yresosize / ( xstep * ystep );
}
public int getXmultiplier (
final String prefix,
final String suffix )
////////////////////////////////////////////////////////////////////////
{
final String key = prefix + "," + suffix;
if ( prefixSuffixToLayerIndexMap.containsKey ( key ) )
{
final int iter = prefixSuffixToLayerIndexMap.get ( key );
final Layer layer = layerList.get ( iter );
return layer.getMultiplierX ( );
}
return 0;
}
public int getYmultiplier (
final String prefix,
final String suffix )
////////////////////////////////////////////////////////////////////////
{
final String key = prefix + "," + suffix;
if ( prefixSuffixToLayerIndexMap.containsKey ( key ) )
{
final int iter = prefixSuffixToLayerIndexMap.get ( key );
final Layer layer = layerList.get ( iter );
return layer.getMultiplierY ( );
}
return 0;
}
/***********************************************************************
* Find out the number of layers starting with prefix string
*
* @param prefix string
* @return number of layers.
***********************************************************************/
public int getLayersize ( final String prefix )
////////////////////////////////////////////////////////////////////////
{
int sum = 0;
for ( final Layer layer : layerList )
{
if ( layer.getPrefix ( ).equals ( prefix ) )
{
sum++;
}
}
return sum;
}
public Layer getLayer (
final String prefix,
final String suffix )
////////////////////////////////////////////////////////////////////////
{
final String key = prefix + "," + suffix;
if ( prefixSuffixToLayerIndexMap.containsKey ( key ) )
{
final int index = prefixSuffixToLayerIndexMap.get ( key );
return layerList.get ( index );
}
return null;
}
/***********************************************************************
* Returns the suffix of the Nth layer with given prefix.
***********************************************************************/
public String getLayerSuffix (
final String prefix,
final int index )
////////////////////////////////////////////////////////////////////////
{
int matchingPrefixIndex = 0;
for ( final Layer layer : layerList )
{
final String layerPrefix = layer.getPrefix ( );
if ( layerPrefix.equals ( prefix ) )
{
if ( matchingPrefixIndex == index )
{
return layer.getSuffix ( );
}
matchingPrefixIndex++;
}
}
System.err.println ( "no layer matched" );
return "no layer matched";
}
@Deprecated
public void connect (
String f_pre,
String f_suf,
String t_pre,
String t_suf,
boolean convergent,
double stre,
byte type,
double delay,
int idum)
////////////////////////////////////////////////////////////////////////
{
//ONLY MAKE ONCE, THEN COPY AND PASTE AND ADD FILE RETRIEVE FUNCTION.
/*
FileReader fr=null;
try{
fr=new FileReader(filename);
}
catch(FileNotFoundException e)
{
System.err.println("Couldn't get File: " + filename);
System.exit(0);
}
BufferedReader br=new BufferedReader(fr);
String currentLine=br.readline();
*/
}
/***********************************************************************
* Build up the Scaffold for later building up network structure.
*
* L connection
*
* This method is called from class SimulatorParser
* method parseScaffoldWithPeriodic(int,Element).
***********************************************************************/
public void popScaffold (
final String fromLayerPrefix,
final String fromLayerSuffix,
final String toLayerPrefix,
final String toLayerSuffix,
final boolean convergent,
final double strength,
final int type,
final double delay,
final double [ ] [ ] trans,
final int hostId,
final boolean periodic )
////////////////////////////////////////////////////////////////////////
{
// double maxOutput = -1.0;
final int
fromLayerMultiplierX
= getXmultiplier ( fromLayerPrefix, fromLayerSuffix ),
fromLayerMultiplierY
= getYmultiplier ( fromLayerPrefix, fromLayerSuffix ),
toLayerMultiplierX
= getXmultiplier ( toLayerPrefix, toLayerSuffix ),
toLayerMultiplierY
= getYmultiplier ( toLayerPrefix, toLayerSuffix );
int
fromLayerStepX, // previously named f_xstep
fromLayerStepY,
fromLayerMultipliedEdgeLengthX, // previously named f_xresosize
fromLayerMultipliedEdgeLengthY;
int
toLayerStepX, // previously named t_xstep
toLayerStepY,
toLayerMultipliedEdgeLengthX, // previously named t_xresosize
toLayerMultipliedEdgeLengthY;
int
denomX = 0,
numX = 0;
int
denomY = 0,
numY = 0;
int
xmagratio = 0,
ymagratio = 0;
int
xborder,
yborder;
int
newx = 0,
newy = 0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
int [ ]
xy = new int [ 2 ];
final int
secX = hostId / sectionsInAxisY,
secY = hostId % sectionsInAxisY;
int
fromLayerStepX2, // previously named xstep_ff
fromLayerStepY2,
fromLayerSectionEndX, // previously named xresosize_ff
fromLayerSectionEndY;
int
toLayerStepX2, // previously named xstep_tt
toLayerStepY2,
toLayerSectionEndX, // previously named xresosize_tt
toLayerSectionEndY;
int
fromLayerSectionOriginX, // previously named xOri_ff
fromLayerSectionOriginY;
int
toLayerSectionOriginX, // previously named xOri_tt
toLayerSectionOriginY;
if ( fromLayerMultiplierX > 0 )
{
fromLayerStepX2 = 1;
final double fromLayerNeuronsPerSectionX
= fromLayerMultiplierX * edgeLengthX / ( double ) sectionsInAxisX;
if ( secX != 0 )
{
fromLayerSectionOriginX
= ( int ) ( fromLayerNeuronsPerSectionX * secX );
}
else
{
fromLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
fromLayerSectionEndX
= ( int ) ( fromLayerNeuronsPerSectionX * ( secX + 1 ) );
}
else
{
fromLayerSectionEndX = fromLayerMultiplierX * edgeLengthX;
}
}
else // fromLayerMultiplierX <= 0
{
fromLayerStepX2 = -fromLayerMultiplierX;
if ( secX != 0 )
{
fromLayerSectionOriginX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX
* ( double ) ( secX ) );
// if(xstep_ff==0)System.out.println("pre:"+f_pre+" suf:"+f_suf);
// try{
fromLayerSectionOriginX = fromLayerSectionOriginX
+ fromLayerStepX2 - fromLayerSectionOriginX % fromLayerStepX2;
// }
// catch(Exception ex)
// {
// throw new RuntimeException("pre:"+f_pre+" suf:"+f_suf);
// }
}
else
{
fromLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
fromLayerSectionEndX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX
* ( double ) ( secX + 1 ) );
fromLayerSectionEndX = fromLayerSectionEndX
+ fromLayerStepX2 - fromLayerSectionEndX % fromLayerStepX2;
if ( fromLayerSectionEndX > edgeLengthX )
{
fromLayerSectionEndX=edgeLengthX;
}
}
else
{
fromLayerSectionEndX = edgeLengthX;
}
}
if ( fromLayerMultiplierY > 0 )
{
fromLayerStepY2 = 1;
final double fromLayerNeuronsPerSectionY
= fromLayerMultiplierY * edgeLengthY / ( double ) sectionsInAxisY;
if ( secY != 0 )
{
fromLayerSectionOriginY
= ( int ) ( fromLayerNeuronsPerSectionY * secY );
}
else
{
fromLayerSectionOriginY = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
fromLayerSectionEndY = ( int )
( fromLayerNeuronsPerSectionY * ( double ) ( secY + 1 ) );
}
else
{
fromLayerSectionEndY = fromLayerMultiplierY * edgeLengthY;
}
}
else // fromLayerMultiplierY <= 0
{
fromLayerStepY2 = -fromLayerMultiplierY;
if ( secY != 0 )
{
fromLayerSectionOriginY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY ) );
fromLayerSectionOriginY = fromLayerSectionOriginY
+ fromLayerStepY2 - fromLayerSectionOriginY % fromLayerStepY2;
}
else
{
fromLayerSectionOriginY = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
fromLayerSectionEndY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY + 1 ) );
fromLayerSectionEndY = fromLayerSectionEndY
+ fromLayerStepY2 - fromLayerSectionEndY % fromLayerStepY2;
if ( fromLayerSectionEndY > edgeLengthY )
{
fromLayerSectionEndY = edgeLengthY;
}
}
else
{
fromLayerSectionEndY = edgeLengthY;
}
}
if ( toLayerMultiplierX > 0 )
{
toLayerStepX2 = 1;
final double toLayerNeuronsPerSectionX
= toLayerMultiplierX * edgeLengthX / ( double ) sectionsInAxisX;
if ( secX != 0 )
{
toLayerSectionOriginX
= ( int ) ( toLayerNeuronsPerSectionX * secX );
}
else
{
toLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
toLayerSectionEndX
= ( int ) ( toLayerNeuronsPerSectionX * ( secX + 1 ) );
}
else
{
toLayerSectionEndX = toLayerMultiplierX * edgeLengthX;
}
}
else
{
toLayerStepX2 = -toLayerMultiplierX;
if ( secX != 0 )
{
toLayerSectionOriginX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX ) );
toLayerSectionOriginX = toLayerSectionOriginX
+ toLayerStepX2 - toLayerSectionOriginX % toLayerStepX2;
}
else
{
toLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
toLayerSectionEndX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX + 1 ) );
toLayerSectionEndX = toLayerSectionEndX
+ toLayerStepX2 - toLayerSectionEndX % toLayerStepX2;
if ( toLayerSectionEndX > edgeLengthX )
{
toLayerSectionEndX = edgeLengthX;
}
}
else
{
toLayerSectionEndX = edgeLengthX;
}
}
if ( toLayerMultiplierY > 0 )
{
toLayerStepY2 = 1;
final double toLayerNeuronsPerSectionY
= toLayerMultiplierY * edgeLengthY / ( double ) sectionsInAxisY;
if ( secY != 0 )
{
toLayerSectionOriginY
= ( int ) ( toLayerNeuronsPerSectionY * secY );
}
else
{
toLayerSectionOriginY = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
toLayerSectionEndY
= ( int ) ( toLayerNeuronsPerSectionY * ( secY + 1 ) );
}
else
{
toLayerSectionEndY = toLayerMultiplierY * edgeLengthY;
}
}
else
{
toLayerStepY2 = -toLayerMultiplierY;
if ( secY != 0 )
{
toLayerSectionOriginY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY ) );
toLayerSectionOriginY = toLayerSectionOriginY
+ toLayerStepY2 - toLayerSectionOriginY % toLayerStepY2;
}
else
{
toLayerSectionOriginY = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
toLayerSectionEndY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY + 1 ) );
toLayerSectionEndY = toLayerSectionEndY
+ toLayerStepY2 - toLayerSectionEndY % toLayerStepY2;
if ( toLayerSectionEndY > edgeLengthY )
{
toLayerSectionEndY = edgeLengthY;
}
}
else
{
toLayerSectionEndY = edgeLengthY;
}
}
// these may not be useful for new neuronal model
if ( type == 1
&& strength > 0 )
{
throw new RuntimeException ( "sign of connection is wrong" );
}
if ( type == 0
&& strength < 0 )
{
throw new RuntimeException ( "sign of connection is wrong" );
}
if ( strength != 0 )
{
if ( fromLayerMultiplierX > 0 )
{
fromLayerStepX = 1;
fromLayerMultipliedEdgeLengthX
= fromLayerMultiplierX * edgeLengthX;
}
else
{
fromLayerStepX = -fromLayerMultiplierX;
fromLayerMultipliedEdgeLengthX = edgeLengthX;
}
if ( fromLayerMultiplierY > 0 )
{
fromLayerStepY = 1;
fromLayerMultipliedEdgeLengthY
= fromLayerMultiplierY * edgeLengthY;
}
else
{
fromLayerStepY = -fromLayerMultiplierY;
fromLayerMultipliedEdgeLengthY = edgeLengthY;
}
if ( toLayerMultiplierX > 0 )
{
toLayerStepX = 1;
toLayerMultipliedEdgeLengthX = toLayerMultiplierX * edgeLengthX;
}
else
{
toLayerStepX = -toLayerMultiplierX;
toLayerMultipliedEdgeLengthX = edgeLengthX;
}
if ( toLayerMultiplierY > 0 )
{
toLayerStepY = 1;
toLayerMultipliedEdgeLengthY = toLayerMultiplierY * edgeLengthY;
}
else
{
toLayerStepY = -toLayerMultiplierY;
toLayerMultipliedEdgeLengthY = edgeLengthY;
}
double [ ] [ ] conn;
//find out the post synaptic neurons belong to which host?
/*
if(convergent) //convergence connections from many to 1, first iterate to side
{
conn = FunUtil.lRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=xOri_ff;iterx<xresosize_ff;iterx+=xstep_ff)
{
for(int itery=yOri_ff;itery<yresosize_ff;itery+=ystep_ff)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), t_pre, t_suf);
newx=xy[0];
newy=xy[1];
// if(neuronID == 18400 && t_pre.equals("SE") && t_suf.equals("U3") ) throw new RuntimeException("18400 has a target at host 6\n"+"x:"+(newx-((int)((double)(conn.length/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep)))+1)*(t_xstep))+"x:"+(newx+((int)((double)(((conn.length%2)==0?conn.length-1:conn.length)/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep))))*(t_xstep))+" y:"+(newy-((int)((double)(conn[0].length/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep)))+1)*(t_ystep))+" y:"+(newy+((int)((double)(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep))))*(t_ystep))+" \n center"+newx+","+newy);
for(int itxx=newx-((int)((double)(conn.length/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep)))+1)*(t_xstep);itxx<=newx+((int)((double)(((conn.length%2)==0?conn.length-1:conn.length)/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep))))*(t_xstep);itxx+=t_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(conn[0].length/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep)))+1)*(t_ystep);ityy<=newy+((int)((double)(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep))))*(t_ystep);ityy+=t_ystep)
{
if(periodic)
{
xborder = itxx % t_xresosize;
yborder = ityy % t_yresosize;
if(xborder<0) xborder+=t_xresosize;
if(yborder<0) yborder+=t_yresosize;
}
else
{
if(itxx >= t_xresosize || itxx < 0 || ityy >= t_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int toIndex = cellmap_slow(t_pre,t_suf,xborder,yborder);
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/f_xstep+(((conn.length%2)==0?conn.length-1:conn.length)/2);
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/f_ystep+(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2);
if(maX>=0 && maX < conn.length && maY>=0 && maY < conn[0].length )
{
if(Math.abs(conn[maX][maY])!=0)
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
// if(neuronID == 18400 && node == 6 ) throw new RuntimeException("18400 "+f_pre+","+f_suf+","+iterx+","+itery+" has a target at host 6\n"+18400+" connects to"+toIndex+" "+t_pre+","+t_suf+","+xborder+","+yborder+" ,which is at 6");
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
}
}
}
}
}
else //divergent
{
conn = FunUtil.rRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=xOri_ff;iterx<xresosize_ff;iterx+=xstep_ff)
{
for(int itery=yOri_ff;itery<yresosize_ff;itery+=ystep_ff)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
if( neuronID <= neuron_end && neuronID >= base )
{
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), t_pre, t_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-conn.length/2*t_xstep;itxx<newx+((conn.length%2)==0?conn.length:conn.length+1)/2*t_xstep;itxx+=t_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-conn[0].length/2*t_ystep;ityy<newy+((conn[0].length%2)==0?conn[0].length:conn[0].length+1)/2*t_ystep;ityy+=t_ystep)
{
if(periodic)
{
xborder = itxx % t_xresosize;
yborder = ityy % t_yresosize;
if(xborder<0) xborder+=t_xresosize;
if(yborder<0) yborder+=t_yresosize;
}
else
{
if(itxx >= t_xresosize || itxx < 0 || ityy >= t_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int toIndex = cellmap_slow(t_pre,t_suf,xborder,yborder);
// synapses=getSynapses(neuronID,delay,toIndex); //read the old synapses;
if(Math.abs(conn[(itxx-newx+conn.length/2*t_xstep)/t_xstep][(ityy-newy+conn[0].length/2*t_ystep)/t_ystep])!=0)
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
}
}
}
}
}
*/
// make connections here.
if ( convergent )
{
// convergence connections from many to 1, first iterate to side
conn = FunUtil.rRotate90 ( trans );
if ( toLayerMultiplierX < 0
&& fromLayerMultiplierX > 0 )
{
numX = fromLayerMultiplierX;
denomX = 1;
}
else if ( toLayerMultiplierX < 0
&& fromLayerMultiplierX < 0 )
{
numX = 1;
denomX = 1;
}
else if ( toLayerMultiplierX > 0
&& fromLayerMultiplierX > 0 )
{
numX = fromLayerMultiplierX;
denomX = toLayerMultiplierX;
}
else if ( toLayerMultiplierX > 0
&& fromLayerMultiplierX < 0 )
{
numX = 1;
denomX = toLayerMultiplierX;
}
if ( toLayerMultiplierY < 0
&& fromLayerMultiplierY > 0 )
{
numY = fromLayerMultiplierY;
denomY = 1;
}
else if ( toLayerMultiplierY < 0
&& fromLayerMultiplierY < 0 )
{
numY = 1;
denomY = 1;
}
else if ( toLayerMultiplierY > 0
&& fromLayerMultiplierY > 0 )
{
numY = fromLayerMultiplierY;
denomY = toLayerMultiplierY;
}
else if ( toLayerMultiplierY > 0
&& fromLayerMultiplierY < 0 )
{
numY = 1;
denomY = toLayerMultiplierY;
}
for ( int toLayerX = toLayerSectionOriginX;
toLayerX < toLayerSectionEndX;
toLayerX += toLayerStepX2 )
{
for ( int toLayerY = toLayerSectionOriginY;
toLayerY < toLayerSectionEndY;
toLayerY += toLayerStepY2 )
{
final int neuronID = cellmap_slow (
toLayerPrefix,
toLayerSuffix,
toLayerX,
toLayerY );
xy = closePoint (
( int ) ( ( double ) numX / ( double ) denomX * toLayerX ),
( int ) ( ( double ) numY / ( double ) denomY * toLayerY ),
fromLayerPrefix,
fromLayerSuffix );
newx = xy [ 0 ];
newy = xy [ 1 ];
// TODO: left off cleaning up source code here
// if(neuronID == 59404
// && f_pre.equals("ONLGN")
// && f_suf.equals("E"))
// throw new RuntimeException(
// "find to and from neuron\n"
// +"x:"+(newx-conn.length/2*f_xstep)
// +"x:"+(newx+((conn.length%2)==0
// ?conn.length:conn.length+1)/2*f_xstep)
// +" y:"+(newy-conn[0].length/2*f_ystep)
// +" y:"+(newy+((conn[0].length%2)==0
// ?conn[0].length:conn[0].length+1)/2*f_ystep)
// +" \n center"+newx+","+newy);
for(int itxx=newx-conn.length/2*fromLayerStepX;itxx<newx+((conn.length%2)==0?conn.length:conn.length+1)/2*fromLayerStepX;itxx+=fromLayerStepX) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-conn[0].length/2*fromLayerStepY;ityy<newy+((conn[0].length%2)==0?conn[0].length:conn[0].length+1)/2*fromLayerStepY;ityy+=fromLayerStepY)
{
if(periodic)
{
xborder = itxx % fromLayerMultipliedEdgeLengthX;
yborder = ityy % fromLayerMultipliedEdgeLengthY;
if(xborder<0) xborder+=fromLayerMultipliedEdgeLengthX;
if(yborder<0) yborder+=fromLayerMultipliedEdgeLengthY;
}
else
{
if(itxx >= fromLayerMultipliedEdgeLengthX || itxx < 0 || ityy >= fromLayerMultipliedEdgeLengthY || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(fromLayerPrefix,fromLayerSuffix,xborder,yborder);
// if(neuronID == 59404 && fromIndex == 18400) throw new RuntimeException("find to and from neuron");
if(Math.abs(conn[(itxx-newx+conn.length/2*fromLayerStepX)/fromLayerStepX][(ityy-newy+conn[0].length/2*fromLayerStepY)/fromLayerStepY])!=0)
{
// if(fromIndex == 18400 && hostId == 6 ) throw new RuntimeException("couting 18400 now");
// try {
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
// }
// catch(Exception ex) {
// throw new RuntimeException("size"+scaffold.length+" fromIndex"+fromIndex+" total"+totalNumNeurons());
// }
}
}
}
}
}
}
else //divergent // change it into convergent
{
conn = FunUtil.lRotate90(trans);
if(toLayerMultiplierX<0&&fromLayerMultiplierX>0)
{
numX = fromLayerMultiplierX;
denomX = 1;
}
else if(toLayerMultiplierX<0&&fromLayerMultiplierX<0)
{
numX = 1;
denomX = 1;
}
else if(toLayerMultiplierX>0&&fromLayerMultiplierX>0)
{
numX = fromLayerMultiplierX;
denomX = toLayerMultiplierX;
}
else if(toLayerMultiplierX>0&&fromLayerMultiplierX<0)
{
numX = 1;
denomX = toLayerMultiplierX;
}
if(toLayerMultiplierY<0&&fromLayerMultiplierY>0)
{
numY = fromLayerMultiplierY;
denomY = 1;
}
else if(toLayerMultiplierY<0&&fromLayerMultiplierY<0)
{
numY = 1;
denomY = 1;
}
else if(toLayerMultiplierY>0&&fromLayerMultiplierY>0)
{
numY = fromLayerMultiplierY;
denomY = toLayerMultiplierY;
}
else if(toLayerMultiplierY>0&&fromLayerMultiplierY<0)
{
numY = 1;
denomY = toLayerMultiplierY;
}
for(int iterx=toLayerSectionOriginX;iterx<toLayerSectionEndX;iterx+=toLayerStepX2)
{
for(int itery=toLayerSectionOriginY;itery<toLayerSectionEndY;itery+=toLayerStepY2)
{
int neuronID=cellmap_slow(toLayerPrefix,toLayerSuffix,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), fromLayerPrefix, fromLayerSuffix);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-((int)((double)(conn.length/2)*(((double)numX/(double)denomX*(double)toLayerStepX/(double)fromLayerStepX)))+1)*(fromLayerStepX);itxx<=newx+((int)((double)(((conn.length%2)==0?conn.length-1:conn.length)/2)*(((double)numX/(double)denomX*(double)toLayerStepX/(double)fromLayerStepX))))*(fromLayerStepX);itxx+=fromLayerStepX) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(conn[0].length/2)*(((double)numY*(double)toLayerStepY/(double)denomY/(double)fromLayerStepY)))+1)*(fromLayerStepY);ityy<=newy+((int)((double)(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2)*(((double)numY*(double)toLayerStepY/(double)denomY/(double)fromLayerStepY))))*(fromLayerStepY);ityy+=fromLayerStepY)
{
if(periodic)
{
xborder = itxx % fromLayerMultipliedEdgeLengthX;
yborder = ityy % fromLayerMultipliedEdgeLengthY;
if(xborder<0) xborder+=fromLayerMultipliedEdgeLengthX;
if(yborder<0) yborder+=fromLayerMultipliedEdgeLengthY;
}
else
{
if(itxx >= fromLayerMultipliedEdgeLengthX || itxx < 0 || ityy >= fromLayerMultipliedEdgeLengthY || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(fromLayerPrefix,fromLayerSuffix,xborder,yborder);
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/toLayerStepX+(((conn.length%2)==0?conn.length-1:conn.length)/2);
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/toLayerStepY+(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2);
if(maX>=0 && maX < conn.length && maY>=0 && maY < conn[0].length )
{
if(Math.abs(conn[maX][maY])!=0)
{
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
}
}
}
}
}
}
}
}
}
/***********************************************************************
* Build up the Scaffold for later buiding up network structure. L connection probability connection
*
* @param f_pre
* @param f_suf
* @param t_pre
* @param t_suf
* @param convergent
* @param stre
* @param type
* @param delay
* @param trans
* @param hostId
* @param periodic
***********************************************************************/
public void popScaffold(String f_pre, String f_suf, String t_pre, String t_suf, boolean convergent, double stre, int type, double delay, double[][] proma, double [][] strma, int hostId, boolean periodic) // probability connections
////////////////////////////////////////////////////////////////////////
{
if(strma!=null && (proma.length != strma.length || proma[0].length != strma[0].length)) throw new RuntimeException("matrix size doesn't match for probability connection");
double maxOutput=-1.0;
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
throw new RuntimeException("sign of connection is wrong");
if(type==0&&stre<0)
throw new RuntimeException("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
double [][] conn=null;
double [][] pconn;
//find out the post synaptic neurons belong to which host?
/*
if(convergent) //convergence connections from many to 1, first iterate to side
{
if(strma!=null) conn = FunUtil.lRotate90(strma);
pconn = FunUtil.lRotate90(proma);
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=xOri_ff;iterx<xresosize_ff;iterx+=xstep_ff)
{
for(int itery=yOri_ff;itery<yresosize_ff;itery+=ystep_ff)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), t_pre, t_suf);
newx=xy[0];
newy=xy[1];
// if(neuronID == 18400 && t_pre.equals("SE") && t_suf.equals("U3") ) throw new RuntimeException("18400 has a target at host 6\n"+"x:"+(newx-((int)((double)(conn.length/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep)))+1)*(t_xstep))+"x:"+(newx+((int)((double)(((conn.length%2)==0?conn.length-1:conn.length)/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep))))*(t_xstep))+" y:"+(newy-((int)((double)(conn[0].length/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep)))+1)*(t_ystep))+" y:"+(newy+((int)((double)(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep))))*(t_ystep))+" \n center"+newx+","+newy);
for(int itxx=newx-((int)((double)(pconn.length/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep)))+1)*(t_xstep);itxx<=newx+((int)((double)(((pconn.length%2)==0?pconn.length-1:pconn.length)/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep))))*(t_xstep);itxx+=t_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(pconn[0].length/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep)))+1)*(t_ystep);ityy<=newy+((int)((double)(((pconn[0].length%2)==0?pconn[0].length-1:pconn[0].length)/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep))))*(t_ystep);ityy+=t_ystep)
{
if(periodic)
{
xborder = itxx % t_xresosize;
yborder = ityy % t_yresosize;
if(xborder<0) xborder+=t_xresosize;
if(yborder<0) yborder+=t_yresosize;
}
else
{
if(itxx >= t_xresosize || itxx < 0 || ityy >= t_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int toIndex = cellmap_slow(t_pre,t_suf,xborder,yborder);
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/f_xstep+(((pconn.length%2)==0?pconn.length-1:pconn.length)/2);
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/f_ystep+(((pconn[0].length%2)==0?pconn[0].length-1:pconn[0].length)/2);
if(maX>=0 && maX < pconn.length && maY>=0 && maY < pconn[0].length )
{
if(strma != null)
{
if(Math.abs(conn[maX][maY])!=0)
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
else
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
}
}
}
}
}
else //divergent
{
if(strma!=null) conn = FunUtil.rRotate90(strma);
pconn = FunUtil.rRotate90(proma);
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=xOri_ff;iterx<xresosize_ff;iterx+=xstep_ff)
{
for(int itery=yOri_ff;itery<yresosize_ff;itery+=ystep_ff)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
if( neuronID <= neuron_end && neuronID >= base )
{
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), t_pre, t_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-pconn.length/2*t_xstep;itxx<newx+((pconn.length%2)==0?pconn.length:pconn.length+1)/2*t_xstep;itxx+=t_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-pconn[0].length/2*t_ystep;ityy<newy+((pconn[0].length%2)==0?pconn[0].length:pconn[0].length+1)/2*t_ystep;ityy+=t_ystep)
{
if(periodic)
{
xborder = itxx % t_xresosize;
yborder = ityy % t_yresosize;
if(xborder<0) xborder+=t_xresosize;
if(yborder<0) yborder+=t_yresosize;
}
else
{
if(itxx >= t_xresosize || itxx < 0 || ityy >= t_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int toIndex = cellmap_slow(t_pre,t_suf,xborder,yborder);
// synapses=getSynapses(neuronID,delay,toIndex); //read the old synapses;
if(strma != null)
{
if(Math.abs(pconn[(itxx-newx+pconn.length/2*t_xstep)/t_xstep][(ityy-newy+pconn[0].length/2*t_ystep)/t_ystep])!=0)
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
else
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
}
}
}
}
}
*/
// make connections here.
if(convergent) //convergence connections from many to 1, first iterate to side
{
if(strma!=null) conn = FunUtil.rRotate90(strma);
pconn = FunUtil.rRotate90(proma);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-pconn.length/2*f_xstep;itxx<newx+((pconn.length%2)==0?pconn.length:pconn.length+1)/2*f_xstep;itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-pconn[0].length/2*f_ystep;ityy<newy+((pconn[0].length%2)==0?pconn[0].length:pconn[0].length+1)/2*f_ystep;ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
// if(neuronID == 59404 && fromIndex == 18400) throw new RuntimeException("find to and from neuron");
if(pconn[(itxx-newx+pconn.length/2*f_xstep)/f_xstep][(ityy-newy+pconn[0].length/2*f_ystep)/f_ystep]> Cnsran.ran2(idum))
{
if(strma != null)
{
if(Math.abs(conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep])!=0)
{
// if(fromIndex == 18400 && hostId == 6 ) throw new RuntimeException("couting 18400 now");
// try {
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
// }
// catch(Exception ex) {
// throw new RuntimeException("size"+scaffold.length+" fromIndex"+fromIndex+" total"+totalNumNeurons());
// }
}
}
else
{
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
}
}
}
}
}
}
}
else //divergent // change it into convergent
{
if(strma!=null) conn = FunUtil.lRotate90(strma);
pconn = FunUtil.lRotate90(proma);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-((int)((double)(pconn.length/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep)))+1)*(f_xstep);itxx<=newx+((int)((double)(((pconn.length%2)==0?pconn.length-1:pconn.length)/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep))))*(f_xstep);itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(pconn[0].length/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep)))+1)*(f_ystep);ityy<=newy+((int)((double)(((pconn[0].length%2)==0?pconn[0].length-1:pconn[0].length)/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep))))*(f_ystep);ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/t_xstep+(((pconn.length%2)==0?pconn.length-1:pconn.length)/2);
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/t_ystep+(((pconn[0].length%2)==0?pconn[0].length-1:pconn[0].length)/2);
if(maX>=0 && maX < pconn.length && maY>=0 && maY < pconn[0].length )
{
if(pconn[maX][maY] > Cnsran.ran2(idum))
{
if(strma != null)
{
if(Math.abs(conn[maX][maY])!=0)
{
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
}
}
else
{
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
}
}
}
}
}
}
}
}
}
}
/***********************************************************************
* Build up the Scaffold for later building up network structure.
* General connection
***********************************************************************/
public void popScaffold (
final String fromLayerPrefix,
final String fromLayerSuffix,
final String toLayerPrefix,
final String toLayerSuffix,
final double strength,
final int type,
final double delay,
final double [ ] [ ] trans,
final int hostId )
////////////////////////////////////////////////////////////////////////
{
// general pop up the scaffold
// double maxOutput=-1.0;
final int
fromLayerMultiplierX
= getXmultiplier ( fromLayerPrefix, fromLayerSuffix ),
fromLayerMultiplierY
= getYmultiplier ( fromLayerPrefix, fromLayerSuffix ),
toLayerMultiplierX
= getXmultiplier ( toLayerPrefix, toLayerSuffix ),
toLayerMultiplierY
= getYmultiplier ( toLayerPrefix, toLayerSuffix );
int
fromLayerStepX, // previously named f_xstep
fromLayerStepY,
fromLayerMultipliedEdgeLengthX, // previously named f_xresosize
fromLayerMultipliedEdgeLengthY;
int
toLayerStepX,
toLayerStepY,
toLayerMultipliedEdgeLengthX,
toLayerMultipliedEdgeLengthY;
int
denomX,
numX;
int
denomY,
numY;
// int xmagratio=0;
// int ymagratio=0;
// int xborder,yborder;
// int newx=0;
// int newy=0;
// int[] xy=new int[2];
final int
secX = hostId / sectionsInAxisY,
secY = hostId % sectionsInAxisY;
int
fromLayerStepX2, // previously named xstep_ff
fromLayerStepY2,
fromLayerSectionEndX, // previously named xresosize_ff
fromLayerSectionEndY;
int
toLayerStepX2,
toLayerStepY2,
toLayerSectionEndX,
toLayerSectionEndY;
int
fromLayerSectionOriginX, // previously named xOri_ff
fromLayerSectionOriginY;
int
toLayerSectionOriginX,
toLayerSectionOriginY;
if ( fromLayerMultiplierX > 0 )
{
fromLayerStepX2 = 1;
final double layerNeuronsPerSectionX
= fromLayerMultiplierX * edgeLengthX / ( double ) sectionsInAxisX;
if ( secX != 0 )
{
fromLayerSectionOriginX
= ( int ) ( layerNeuronsPerSectionX * secX );
}
else
{
fromLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
fromLayerSectionEndX
= ( int ) ( layerNeuronsPerSectionX * ( secX + 1 ) );
}
else
{
fromLayerSectionEndX = fromLayerMultiplierX * edgeLengthX;
}
}
else // f_xmulti <= 0
{
fromLayerStepX2 = -fromLayerMultiplierX;
if ( secX != 0 )
{
fromLayerSectionOriginX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX
* ( double ) ( secX ) );
fromLayerSectionOriginX = fromLayerSectionOriginX
+ fromLayerStepX2 - fromLayerSectionOriginX % fromLayerStepX2;
}
else
{
fromLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
fromLayerSectionEndX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX
* ( double ) ( secX + 1 ) );
fromLayerSectionEndX = fromLayerSectionEndX
+ fromLayerStepX2 - fromLayerSectionEndX % fromLayerStepX2;
if ( fromLayerSectionEndX > edgeLengthX )
{
fromLayerSectionEndX = edgeLengthX;
}
}
else
{
fromLayerSectionEndX = edgeLengthX;
}
}
if ( fromLayerMultiplierY > 0 )
{
fromLayerStepY2 = 1;
final double layerNeuronsPerSectionY
= fromLayerMultiplierY * edgeLengthY / ( double ) sectionsInAxisY;
if ( secY != 0 )
{
fromLayerSectionOriginY
= ( int ) ( layerNeuronsPerSectionY * secY );
}
else
{
fromLayerSectionOriginY = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
fromLayerSectionEndY
= ( int ) ( layerNeuronsPerSectionY * ( secY + 1 ) );
}
else
{
fromLayerSectionEndY = fromLayerMultiplierY * edgeLengthY;
}
}
else
{
fromLayerStepY2 = -fromLayerMultiplierY;
if ( secY != 0 )
{
fromLayerSectionOriginY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY ) );
fromLayerSectionOriginY = fromLayerSectionOriginY
+ fromLayerStepY2 - fromLayerSectionOriginY % fromLayerStepY2;
}
else
{
fromLayerSectionOriginY = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
fromLayerSectionEndY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY + 1 ) );
fromLayerSectionEndY = fromLayerSectionEndY
+ fromLayerStepY2 - fromLayerSectionEndY % fromLayerStepY2;
if ( fromLayerSectionEndY > edgeLengthY )
{
fromLayerSectionEndY = edgeLengthY;
}
}
else
{
fromLayerSectionEndY = edgeLengthY;
}
}
if ( toLayerMultiplierX > 0 )
{
toLayerStepX2 = 1;
if ( secX != 0 )
{
toLayerSectionOriginX = ( int ) ( ( double ) toLayerMultiplierX
* ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX ) );
}
else
{
toLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
toLayerSectionEndX = ( int ) ( ( double ) toLayerMultiplierX
* ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX + 1 ) );
}
else
{
toLayerSectionEndX = toLayerMultiplierX * edgeLengthX;
}
}
else
{
toLayerStepX2 = -toLayerMultiplierX;
if ( secX != 0 )
{
toLayerSectionOriginX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX ) );
toLayerSectionOriginX = toLayerSectionOriginX
+ toLayerStepX2 - toLayerSectionOriginX % toLayerStepX2;
}
else
{
toLayerSectionOriginX = 0;
}
if ( secX != sectionsInAxisX - 1 )
{
toLayerSectionEndX = ( int ) ( ( double ) edgeLengthX
/ ( double ) sectionsInAxisX * ( double ) ( secX + 1 ) );
toLayerSectionEndX = toLayerSectionEndX
+ toLayerStepX2 - toLayerSectionEndX % toLayerStepX2;
if ( toLayerSectionEndX > edgeLengthX )
{
toLayerSectionEndX = edgeLengthX;
}
}
else
{
toLayerSectionEndX = edgeLengthX;
}
}
if ( toLayerMultiplierY > 0 )
{
toLayerStepY2 = 1;
if ( secY != 0 )
{
toLayerSectionOriginY = ( int ) ( ( double ) toLayerMultiplierY
* ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY ) );
}
else
{
toLayerSectionOriginY = 0;
}
if ( secY != sectionsInAxisY - 1 )
{
toLayerSectionEndY = ( int ) ( ( double ) toLayerMultiplierY
* ( double ) edgeLengthY / ( double ) sectionsInAxisY
* ( double ) ( secY + 1 ) );
}
else
{
toLayerSectionEndY = toLayerMultiplierY * edgeLengthY;
}
}
else
{
toLayerStepY2 = -toLayerMultiplierY;
if ( secY != 0 )
{
toLayerSectionOriginY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY ) );
toLayerSectionOriginY = toLayerSectionOriginY
+ toLayerStepY2 - toLayerSectionOriginY % toLayerStepY2;
}
else
{
toLayerSectionOriginY=0;
}
if ( secY != sectionsInAxisY-1 )
{
toLayerSectionEndY = ( int ) ( ( double ) edgeLengthY
/ ( double ) sectionsInAxisY * ( double ) ( secY + 1 ) );
toLayerSectionEndY = toLayerSectionEndY
+ toLayerStepY2 - toLayerSectionEndY % toLayerStepY2;
if ( toLayerSectionEndY > edgeLengthY )
{
toLayerSectionEndY = edgeLengthY;
}
}
else
{
toLayerSectionEndY = edgeLengthY;
}
}
// these may not be useful for new neuronal model
if ( type == 1
&& strength > 0 )
{
throw new RuntimeException ( "sign of connection is wrong" );
}
if ( type == 0
&& strength < 0 )
{
throw new RuntimeException ( "sign of connection is wrong" );
}
if ( strength != 0 )
{
if ( fromLayerMultiplierX > 0 )
{
fromLayerStepX = 1;
fromLayerMultipliedEdgeLengthX
= fromLayerMultiplierX * edgeLengthX;
}
else
{
fromLayerStepX = -fromLayerMultiplierX;
fromLayerMultipliedEdgeLengthX = edgeLengthX;
}
if ( fromLayerMultiplierY > 0 )
{
fromLayerStepY = 1;
fromLayerMultipliedEdgeLengthY
= fromLayerMultiplierY * edgeLengthY;
}
else
{
fromLayerStepY = -fromLayerMultiplierY;
fromLayerMultipliedEdgeLengthY = edgeLengthY;
}
if ( toLayerMultiplierX > 0 )
{
toLayerStepX = 1;
toLayerMultipliedEdgeLengthX = toLayerMultiplierX * edgeLengthX;
}
else
{
toLayerStepX = -toLayerMultiplierX;
toLayerMultipliedEdgeLengthX = edgeLengthX;
}
if ( toLayerMultiplierY > 0 )
{
toLayerStepY = 1;
toLayerMultipliedEdgeLengthY = toLayerMultiplierY * edgeLengthY;
}
else
{
toLayerStepY = -toLayerMultiplierY;
toLayerMultipliedEdgeLengthY = edgeLengthY;
}
//find out the post synaptic neurons belong to which host?
/*
{
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=xOri_ff;iterx<xresosize_ff;iterx+=xstep_ff)
{
for(int itery=yOri_ff;itery<yresosize_ff;itery+=ystep_ff)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
int fIndex = (iterx / f_xstep)
* (f_yresosize / f_ystep) + itery / f_ystep;
for(int itxx=0;itxx<t_xresosize;itxx+=t_xstep)
{
for(int ityy=0;ityy<t_yresosize;ityy+=t_ystep)
{
int toIndex = cellmap_slow(t_pre,t_suf,itxx,ityy);
int tIndex = (itxx / t_xstep)*(t_yresosize / t_ystep)
+ ityy / t_ystep;
if(Math.abs(trans[fIndex % trans.length]
[tIndex % trans[0].length])!=0)
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
// if the neuron doen'st have a target synapse at node
// then set it.
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0)
{
neurons[neuronID - base].setTHost(
(neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
}
}
}
}
*/
{
if ( toLayerMultiplierX < 0
&& fromLayerMultiplierX > 0 )
{
numX = fromLayerMultiplierX;
denomX = 1;
}
else if ( toLayerMultiplierX < 0
&& fromLayerMultiplierX < 0 )
{
numX = 1;
denomX = 1;
}
else if ( toLayerMultiplierX > 0
&& fromLayerMultiplierX > 0 )
{
numX = fromLayerMultiplierX;
denomX = toLayerMultiplierX;
}
else if ( toLayerMultiplierX > 0
&& fromLayerMultiplierX < 0 )
{
numX = 1;
denomX = toLayerMultiplierX;
}
if ( toLayerMultiplierY < 0
&& fromLayerMultiplierY > 0 )
{
numY = fromLayerMultiplierY;
denomY = 1;
}
else if ( toLayerMultiplierY < 0
&& fromLayerMultiplierY < 0 )
{
numY = 1;
denomY = 1;
}
else if ( toLayerMultiplierY > 0
&& fromLayerMultiplierY > 0 )
{
numY = fromLayerMultiplierY;
denomY = toLayerMultiplierY;
}
else if ( toLayerMultiplierY > 0
&& fromLayerMultiplierY < 0 )
{
numY = 1;
denomY = toLayerMultiplierY;
}
for ( int toLayerX = toLayerSectionOriginX;
toLayerX < toLayerSectionEndX;
toLayerX += toLayerStepX2 )
{
for ( int toLayerY = toLayerSectionOriginY;
toLayerY < toLayerSectionEndY;
toLayerY += toLayerStepY2 )
{
final int neuronID = cellmap_slow (
toLayerPrefix,
toLayerSuffix,
toLayerX,
toLayerY );
final int tIndex = ( toLayerX / toLayerStepX )
* ( toLayerMultipliedEdgeLengthY / toLayerStepY )
+ toLayerY / toLayerStepY;
for ( int itxx = 0;
itxx < fromLayerMultipliedEdgeLengthX;
itxx += fromLayerStepX )
{
for ( int ityy = 0;
ityy < fromLayerMultipliedEdgeLengthY;
ityy += fromLayerStepY )
{
final int fromIndex = cellmap_slow (
fromLayerPrefix,
fromLayerSuffix,
itxx,
ityy );
final int fIndex = ( itxx / fromLayerStepX )
* ( fromLayerMultipliedEdgeLengthY / fromLayerStepY )
+ ityy / fromLayerStepY;
if ( Math.abs (
trans [ fIndex % trans.length ]
[ tIndex % trans [ 0 ].length ] ) != 0 )
{
Map<String, SizeID> content;
if ( !scaffold.containsKey ( fromIndex ) )
{
scaffold.put (
fromIndex,
content = ( new TreeMap<String, SizeID> ( ) ) );
}
else
{
content = scaffold.get ( fromIndex );
}
if ( !content.containsKey ( String.valueOf ( delay ) ) )
{
// number of branches
final int totSize = content.size ( );
content.put (
String.valueOf ( delay ),
new SizeID ( totSize, 1 ) );
}
else
{
( content.get ( String.valueOf ( delay ) ).size )++;
}
}
}
}
}
}
}
}
}
/***********************************************************************
* Build up the Scaffold for later buiding up network structure.
* General population connection
*
* @param f_pre
* @param f_suf
* @param t_pre
* @param t_suf
* @param convergent
* @param stre
* @param type
* @param delay
* @param trans
* @param hostId
* @param periodic
***********************************************************************/
public void popScaffold(String f_pre, String f_suf, String t_pre, String t_suf, double stre, int type, double delay, double [][] proma, double[][] strma, int hostId) //general probability pop up the scaffold
////////////////////////////////////////////////////////////////////////
{
double maxOutput=-1.0;
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
throw new RuntimeException("sign of connection is wrong");
if(type==0&&stre<0)
throw new RuntimeException("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
//find out the post synaptic neurons belong to which host?
/*
{
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=xOri_ff;iterx<xresosize_ff;iterx+=xstep_ff)
{
for(int itery=yOri_ff;itery<yresosize_ff;itery+=ystep_ff)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
int fIndex = (iterx / f_xstep) * (f_yresosize / f_ystep) + itery / f_ystep;
for(int itxx=0;itxx<t_xresosize;itxx+=t_xstep)
{
for(int ityy=0;ityy<t_yresosize;ityy+=t_ystep)
{
int toIndex = cellmap_slow(t_pre,t_suf,itxx,ityy);
int tIndex = (itxx / t_xstep)*(t_yresosize / t_ystep) + ityy / t_ystep;
if(strma != null)
{
if(Math.abs(strma[fIndex % strma.length][tIndex % strma[0].length])!=0)
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
else
{
int node=FunUtil.hostId(nodeEndIndices,toIndex);
if((neurons[neuronID - base].getTHost() & (1L<<node) )==0) // if the neuron doen'st have a target synapse at node then set it.
{
neurons[neuronID - base].setTHost((neurons[neuronID - base].getTHost() | (1L<< node)));
}
}
}
}
}
}
}
*/
{
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
int tIndex = (iterx / xstep_tt) * (yresosize_tt / ystep_tt) + itery / ystep_tt;
for(int itxx=0;itxx<f_xresosize;itxx+=f_xstep)
{
for(int ityy=0;ityy<f_yresosize;ityy+=f_ystep)
{
int fromIndex = cellmap_slow(f_pre,f_suf,itxx,ityy);
int fIndex = (itxx / f_xstep)*(f_yresosize / f_ystep) + ityy / f_ystep;
if(Math.abs(proma[fIndex % proma.length][tIndex % proma[0].length])> Cnsran.ran2(idum))
{
if(strma != null)
{
if(Math.abs(strma[fIndex % strma.length][tIndex % strma[0].length])!=0)
{
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
}
}
else
{
Map<String, SizeID> content;
if(!scaffold.containsKey(fromIndex))
{
scaffold.put(fromIndex,content = (new TreeMap<String, SizeID>()) );
}
else
{
content = scaffold.get(fromIndex);
}
if(!content.containsKey(String.valueOf(delay)))
{
int totSize=content.size(); // number of branches
content.put(String.valueOf(delay), new SizeID(totSize,1));
}
else
{
(content.get(String.valueOf(delay)).size)++;
}
}
}
}
}
}
}
}
}
}
/***********************************************************************
* For nethost with id Hostid, build up the structure by using the scaffold build before.
*
* @param hostId
***********************************************************************/
public void buildStructure(int hostId)
{
// axons = new HashMap<Integer, Axon>((int)((double)scaffold.size()/0.75));
axons = new HashMap<Integer, Axon>(scaffold.size());
Set entries = scaffold.entrySet();
Iterator entryIter = entries.iterator();
while(entryIter.hasNext())
{
Map.Entry<Integer, Map<String, SizeID> > entry = (Map.Entry<Integer, Map<String, SizeID> >)entryIter.next();
Integer key = entry.getKey();
Map<String, SizeID> value = entry.getValue();
Iterator<String> iter = value.keySet().iterator();
Axon caxon;
if(!axons.containsKey(key))
{
axons.put(key, caxon=(new Axon()));
}
else
{
caxon = axons.get(key);
}
caxon.branches = new Branch[value.size()];
// Branch[] mybranches=new Branch[scaffold[a].size()];
// int currBranch=0;
while(iter.hasNext())
{
String branchKey = iter.next();
SizeID sid = value.get(branchKey);
Synapse[] syns=new Synapse[(int)(sid.size)];
sid.size=0;
// double delay=Double.parseDouble(branchKey.substring(0,branchKey.lastIndexOf(" ")));
double delay=Double.parseDouble(branchKey);
// mybranches[currBranch]=new Branch(syns,delay);
caxon.branches[(int)(sid.id)]=new Branch(syns,delay);
// currBranch++;
}
}
}
public void sortSynapses(int hostId)
////////////////////////////////////////////////////////////////////////
{
Iterator<Axon> values = axons.values().iterator();
while(values.hasNext())
{
Axon caxon = values.next();
for(int i=0;i<caxon.branches.length; i++)
{
Arrays.sort(caxon.branches[i].synapses);
}
}
}
/***********************************************************************
* Makeing connections between from and to layer of neurons, L connection.
*
* @param f_pre
* @param f_suf
* @param t_pre
* @param t_suf
* @param convergent
* @param stre
* @param type
* @param delay
* @param trans
* @param hostId
* @param periodic
* @return Largest weight
***********************************************************************/
public double connect(String f_pre, String f_suf, String t_pre, String t_suf, boolean convergent, double stre, int type, double delay, double[][] trans, int hostId, boolean periodic)
////////////////////////////////////////////////////////////////////////
{
double maxOutput=-1.0;
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
double [][] conn;
// make connections here.
if(convergent) //convergence connections from many to 1, first iterate to side
{
conn = FunUtil.rRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-conn.length/2*f_xstep;itxx<newx+((conn.length%2)==0?conn.length:conn.length+1)/2*f_xstep;itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-conn[0].length/2*f_ystep;ityy<newy+((conn[0].length%2)==0?conn[0].length:conn[0].length+1)/2*f_ystep;ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
if(Math.abs(conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep])!=0)
{
double synWei = stre*conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
// int node=FunUtil.hostId(nodeEndIndices,toIndex);
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
//if(fromIndex == 38036 && hostId == 1) throw new RuntimeException("this has a syn"+axons[fromIndex].branches.length);
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
// neurons[neuronID-base].getAxon().branches[(int)(sid.id)].synapses[(int)(sid.size)] = new Synapse(toIndex,synWei,type);
sid.size++;
}
}
}
}
}
}
else //divergent // change it into convergent
{
conn = FunUtil.lRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-((int)((double)(conn.length/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep)))+1)*(f_xstep);itxx<=newx+((int)((double)(((conn.length%2)==0?conn.length-1:conn.length)/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep))))*(f_xstep);itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(conn[0].length/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep)))+1)*(f_ystep);ityy<=newy+((int)((double)(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep))))*(f_ystep);ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/t_xstep+(((conn.length%2)==0?conn.length-1:conn.length)/2);
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/t_ystep+(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2);
if(maX>=0 && maX < conn.length && maY>=0 && maY < conn[0].length )
{
if(Math.abs(conn[maX][maY])!=0)
{
double synWei = stre*conn[maX][maY];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
sid.size++;
}
}
}
}
}
}
}
}
return maxOutput;
}
public void setSeed(Seed i)
////////////////////////////////////////////////////////////////////////
{
backseed = i.seed;
System.arraycopy(Cnsran.iv,0,back_iv,0,32);
back_iy = Cnsran.iy;
back_idum2=Cnsran.idum2;
this.idum = new Seed(backseed);
}
public void reSetSeed()
////////////////////////////////////////////////////////////////////////
{
this.idum = new Seed(backseed);
System.arraycopy(back_iv,0,Cnsran.iv,0,32);
Cnsran.iy = back_iy;
Cnsran.idum2 = back_idum2;
}
/***********************************************************************
* Makeing connections between from and to layer of neurons, probability connection.
*
* @param f_pre
* @param f_suf
* @param t_pre
* @param t_suf
* @param convergent
* @param stre
* @param type
* @param delay
* @param trans
* @param hostId
* @param periodic
* @return Largest weight
***********************************************************************/
public double connect(String f_pre, String f_suf, String t_pre, String t_suf, boolean convergent, double stre, int type, double delay, double[][] proma, double [][] strma, int hostId, boolean periodic) // probability connections
////////////////////////////////////////////////////////////////////////
{
if(strma!=null && (proma.length != strma.length || proma[0].length != strma[0].length)) throw new RuntimeException("matrix size doesn't match for probability connection");
double maxOutput=-1.0;
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
double [][] conn=null;
double [][] pconn;
// make connections here.
if(convergent) //convergence connections from many to 1, first iterate to side
{
if(strma!=null) conn = FunUtil.rRotate90(strma);
pconn = FunUtil.rRotate90(proma);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-pconn.length/2*f_xstep;itxx<newx+((pconn.length%2)==0?pconn.length:pconn.length+1)/2*f_xstep;itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-pconn[0].length/2*f_ystep;ityy<newy+((pconn[0].length%2)==0?pconn[0].length:pconn[0].length+1)/2*f_ystep;ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
if(pconn[(itxx-newx+pconn.length/2*f_xstep)/f_xstep][(ityy-newy+pconn[0].length/2*f_ystep)/f_ystep]> Cnsran.ran2(idum))
{
if(strma != null)
{
if(Math.abs(conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep])!=0)
{
double synWei = stre*conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
// int node=FunUtil.hostId(nodeEndIndices,toIndex);
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
//if(fromIndex == 38036 && hostId == 1) throw new RuntimeException("this has a syn"+axons[fromIndex].branches.length);
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
// neurons[neuronID-base].getAxon().branches[(int)(sid.id)].synapses[(int)(sid.size)] = new Synapse(toIndex,synWei,type);
sid.size++;
}
}
else
{
double synWei = stre;
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
// int node=FunUtil.hostId(nodeEndIndices,toIndex);
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
//if(fromIndex == 38036 && hostId == 1) throw new RuntimeException("this has a syn"+axons[fromIndex].branches.length);
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
// neurons[neuronID-base].getAxon().branches[(int)(sid.id)].synapses[(int)(sid.size)] = new Synapse(toIndex,synWei,type);
sid.size++;
}
}
}
}
}
}
}
else //divergent // change it into convergent
{
if(strma!=null) conn = FunUtil.lRotate90(strma);
pconn = FunUtil.lRotate90(proma);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-((int)((double)(pconn.length/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep)))+1)*(f_xstep);itxx<=newx+((int)((double)(((pconn.length%2)==0?pconn.length-1:pconn.length)/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep))))*(f_xstep);itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(pconn[0].length/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep)))+1)*(f_ystep);ityy<=newy+((int)((double)(((pconn[0].length%2)==0?pconn[0].length-1:pconn[0].length)/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep))))*(f_ystep);ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/t_xstep+(((pconn.length%2)==0?pconn.length-1:pconn.length)/2);
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/t_ystep+(((pconn[0].length%2)==0?pconn[0].length-1:pconn[0].length)/2);
if(maX>=0 && maX < pconn.length && maY>=0 && maY < pconn[0].length )
{
if(pconn[maX][maY] > Cnsran.ran2(idum))
{
if(strma != null)
{
if(Math.abs(conn[maX][maY])!=0)
{
double synWei = stre*conn[maX][maY];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
sid.size++;
}
}
else
{
double synWei = stre;
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
sid.size++;
}
}
}
}
}
}
}
}
}
return maxOutput;
}
/***********************************************************************
* Makeing connections between from and to layer of neurons, general connection.
*
* @param f_pre
* @param f_suf
* @param t_pre
* @param t_suf
* @param convergent
* @param stre
* @param type
* @param delay
* @param trans
* @param hostId
* @param periodic
* @return Largest weight
***********************************************************************/
public double connect(String f_pre, String f_suf, String t_pre, String t_suf, double stre, int type, double delay, double[][] trans, int hostId) //general connection
////////////////////////////////////////////////////////////////////////
{
double maxOutput=-1.0;
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
TreeSet<Synapse> synapses;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
int tIndex = (iterx / t_xstep) * (t_yresosize / t_ystep) + itery / t_ystep;
for(int itxx=0;itxx<f_xresosize;itxx+=f_xstep)
{
for(int ityy=0;ityy<f_yresosize;ityy+=f_ystep)
{
int fIndex = (itxx / f_xstep)*(f_yresosize / f_ystep) + ityy / f_ystep;
int fromIndex = cellmap_slow(f_pre,f_suf,itxx,ityy);
if(Math.abs(trans[fIndex % trans.length][tIndex % trans[0].length])!=0)
{
double synWei = stre*trans[fIndex % trans.length][tIndex % trans[0].length];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
sid.size++;
}
}
}
}
}
}
return maxOutput;
}
/***********************************************************************
* Makeing connections between from and to layer of neurons, general probability connection.
*
* @param f_pre
* @param f_suf
* @param t_pre
* @param t_suf
* @param convergent
* @param stre
* @param type
* @param delay
* @param trans
* @param hostId
* @param periodic
* @return Largest weight
***********************************************************************/
public double connectgp(String f_pre, String f_suf, String t_pre, String t_suf, double stre, int type, double delay, double[][] proma, double [][] strma, int hostId) //general probability connection
////////////////////////////////////////////////////////////////////////
{
double maxOutput=-1.0;
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
TreeSet<Synapse> synapses;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
int tIndex = (iterx / t_xstep) * (t_yresosize / t_ystep) + itery / t_ystep;
for(int itxx=0;itxx<f_xresosize;itxx+=f_xstep)
{
for(int ityy=0;ityy<f_yresosize;ityy+=f_ystep)
{
int fIndex = (itxx / f_xstep)*(f_yresosize / f_ystep) + ityy / f_ystep;
int fromIndex = cellmap_slow(f_pre,f_suf,itxx,ityy);
if(Math.abs(proma[fIndex % proma.length][tIndex % proma[0].length])> Cnsran.ran2(idum))
{
if(strma != null)
{
if(Math.abs(strma[fIndex % strma.length][tIndex % strma[0].length])!=0)
{
double synWei = stre*strma[fIndex % strma.length][tIndex % strma[0].length];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
sid.size++;
}
}
else
{
double synWei = stre;
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
axons.get(fromIndex).branches[(int)(sid.id)].synapses[(int)(sid.size)]
= modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei );
numSYN++;
sid.size++;
}
}
}
}
}
}
}
return maxOutput;
}
@Deprecated
public double changeConnection(String f_pre, String f_suf, String t_pre, String t_suf, boolean convergent, double stre, int type, double delay, double[][] trans, int hostId, boolean periodic)
////////////////////////////////////////////////////////////////////////
{
double maxOutput=-1.0;
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
double [][] conn;
// make connections here.
if(convergent) //convergence connections from many to 1, first iterate to side
{
conn = FunUtil.rRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-conn.length/2*f_xstep;itxx<newx+((conn.length%2)==0?conn.length:conn.length+1)/2*f_xstep;itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-conn[0].length/2*f_ystep;ityy<newy+((conn[0].length%2)==0?conn[0].length:conn[0].length+1)/2*f_ystep;ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
if(Math.abs(conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep])!=0)
{
double synWei = stre*conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
// int node=FunUtil.hostId(nodeEndIndices,toIndex);
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
final int index = Arrays.binarySearch (
axons.get ( fromIndex ).branches [ ( int ) ( sid.id ) ].synapses,
modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei ) );
if(index>=0)
{
final MutableSynapse synapseMut = ( MutableSynapse )
axons.get(fromIndex).branches[(int)(sid.id)].synapses[index];
synapseMut.setWeight ( ( float ) synWei );
}
else
{
throw new RuntimeException("modify none existing synapse");
}
}
}
}
}
}
}
else //divergent // change it into convergent
{
conn = FunUtil.lRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-((int)((double)(conn.length/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep)))+1)*(f_xstep);itxx<=newx+((int)((double)(((conn.length%2)==0?conn.length-1:conn.length)/2)*(((double)numX/(double)denomX*(double)t_xstep/(double)f_xstep))))*(f_xstep);itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(conn[0].length/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep)))+1)*(f_ystep);ityy<=newy+((int)((double)(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2)*(((double)numY*(double)t_ystep/(double)denomY/(double)f_ystep))))*(f_ystep);ityy+=f_ystep)
{
if(periodic)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
}
else
{
if(itxx >= f_xresosize || itxx < 0 || ityy >= f_yresosize || ityy<0) // out of boundary
{
continue;
}
else //within boundary
{
xborder = itxx;
yborder = ityy;
}
}
int fromIndex = cellmap_slow(f_pre,f_suf,xborder,yborder);
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/t_xstep+(((conn.length%2)==0?conn.length-1:conn.length)/2);
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/t_ystep+(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2);
if(maX>=0 && maX < conn.length && maY>=0 && maY < conn[0].length )
{
if(Math.abs(conn[maX][maY])!=0)
{
double synWei = stre*conn[maX][maY];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
int index = Arrays.binarySearch (
axons.get(fromIndex).branches[(int)(sid.id)].synapses,
modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei ) );
if(index>=0)
{
final MutableSynapse synapseMut = ( MutableSynapse )
axons.get(fromIndex).branches[(int)(sid.id)].synapses[index];
synapseMut.setWeight ( ( float ) synWei );
}
else
{
throw new RuntimeException("modify none existing synapse");
}
}
}
}
}
}
}
}
}
return maxOutput;
}
@Deprecated
public double changeConnection(String f_pre, String f_suf, String t_pre, String t_suf, double stre, int type, double delay, double[][] trans, int hostId) //general change connection
////////////////////////////////////////////////////////////////////////
{
double maxOutput=-1.0;
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
// double[] curr=new double[2];
// curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
TreeSet<Synapse> synapses;
int[] xy=new int[2];
int secX = hostId/sectionsInAxisY;
int secY = hostId%sectionsInAxisY;
int xstep_ff,ystep_ff,xresosize_ff,yresosize_ff;
int xstep_tt,ystep_tt,xresosize_tt,yresosize_tt;
int xOri_ff,yOri_ff;
int xOri_tt,yOri_tt;
if(f_xmulti>0)
{
xstep_ff=1;
if(secX!=0)
{
xOri_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)f_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_ff=f_xmulti*edgeLengthX;
}
}
else
{
xstep_ff=-f_xmulti;
if(secX!=0)
{
xOri_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_ff=xOri_ff + xstep_ff - xOri_ff %xstep_ff;
}
else
{
xOri_ff=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_ff=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_ff=xresosize_ff + xstep_ff - xresosize_ff % xstep_ff;
if(xresosize_ff>edgeLengthX)xresosize_ff=edgeLengthX;
}
else
{
xresosize_ff=edgeLengthX;
}
}
if(f_ymulti>0)
{
ystep_ff=1;
if(secY!=0)
{
yOri_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)f_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_ff=f_ymulti*edgeLengthY;
}
}
else
{
ystep_ff=-f_ymulti;
if(secY!=0)
{
yOri_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_ff=yOri_ff + ystep_ff - yOri_ff % ystep_ff;
}
else
{
yOri_ff=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_ff=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_ff=yresosize_ff + ystep_ff - yresosize_ff % ystep_ff;
if(yresosize_ff>edgeLengthY)yresosize_ff=edgeLengthY;
}
else
{
yresosize_ff=edgeLengthY;
}
}
if(t_xmulti>0)
{
xstep_tt=1;
if(secX!=0)
{
xOri_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)t_xmulti*(double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
}
else
{
xresosize_tt=t_xmulti*edgeLengthX;
}
}
else
{
xstep_tt=-t_xmulti;
if(secX!=0)
{
xOri_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX));
xOri_tt=xOri_tt + xstep_tt - xOri_tt %xstep_tt;
}
else
{
xOri_tt=0;
}
if(secX!=sectionsInAxisX-1)
{
xresosize_tt=(int)((double)edgeLengthX/(double)sectionsInAxisX*(double)(secX+1));
xresosize_tt=xresosize_tt + xstep_tt - xresosize_tt % xstep_tt;
if(xresosize_tt>edgeLengthX)xresosize_tt=edgeLengthX;
}
else
{
xresosize_tt=edgeLengthX;
}
}
if(t_ymulti>0)
{
ystep_tt=1;
if(secY!=0)
{
yOri_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)t_ymulti*(double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
}
else
{
yresosize_tt=t_ymulti*edgeLengthY;
}
}
else
{
ystep_tt=-t_ymulti;
if(secY!=0)
{
yOri_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY));
yOri_tt=yOri_tt + ystep_tt - yOri_tt % ystep_tt;
}
else
{
yOri_tt=0;
}
if(secY!=sectionsInAxisY-1)
{
yresosize_tt=(int)((double)edgeLengthY/(double)sectionsInAxisY*(double)(secY+1));
yresosize_tt=yresosize_tt + ystep_tt - yresosize_tt % ystep_tt;
if(yresosize_tt>edgeLengthY)yresosize_tt=edgeLengthY;
}
else
{
yresosize_tt=edgeLengthY;
}
}
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=xOri_tt;iterx<xresosize_tt;iterx+=xstep_tt)
{
for(int itery=yOri_tt;itery<yresosize_tt;itery+=ystep_tt)
{
int neuronID=cellmap_slow(t_pre,t_suf,iterx,itery);
int tIndex = (iterx / t_xstep) * (t_yresosize / t_ystep) + itery / t_ystep;
for(int itxx=0;itxx<f_xresosize;itxx+=f_xstep)
{
for(int ityy=0;ityy<f_yresosize;ityy+=f_ystep)
{
int fIndex = (itxx / f_xstep)*(f_yresosize / f_ystep) + ityy / f_ystep;
int fromIndex = cellmap_slow(f_pre,f_suf,itxx,ityy);
if(Math.abs(trans[fIndex % trans.length][tIndex % trans[0].length])!=0)
{
double synWei = stre*trans[fIndex % trans.length][tIndex % trans[0].length];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
SizeID sid = scaffold.get(fromIndex).get(String.valueOf(delay));
int index = Arrays.binarySearch (
axons.get(fromIndex).branches[(int)(sid.id)].synapses,
modelFactory.createSynapse (
neuronID,
( byte ) type,
( float ) synWei ) );
if(index>=0)
{
final MutableSynapse synapseMut = ( MutableSynapse )
axons.get(fromIndex).branches[(int)(sid.id)].synapses[index];
synapseMut.setWeight ( ( float ) synWei );
}
else
{
throw new RuntimeException("modify none existing synapse");
}
}
}
}
}
}
}
return maxOutput;
}
/*
public double connect(String f_pre, String f_suf, String t_pre, String t_suf, boolean convergent, double stre, int type, double delay, double[][] trans, int hostId)
////////////////////////////////////////////////////////////////////////
{
double maxOutput=-1.0;
double [][] conn = FunUtil.rRotate90(trans);
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
double[] curr=new double[2];
curr[0]=0.0;curr[1]=0.0;//no initial currents in neurons
// String fromNeur,toNeur;
TreeSet<Synapse> synapses;
int[] xy=new int[2];
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*xedgeLength;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=xedgeLength;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*yedgeLength;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=yedgeLength;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*xedgeLength;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=xedgeLength;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*yedgeLength;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=yedgeLength;
}
if(convergent) //convergence connections from many to 1, first iterate to side
{
if(t_xmulti<0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = 1;
// xmagratio=f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
// xmagratio=1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = f_xmulti;
denomX = t_xmulti;
// xmagratio=(f_xmulti/t_xmulti);
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = 1;
denomX = t_xmulti;
// xmagratio=1/t_xmulti;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = 1;
// ymagratio=(int)f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
// ymagratio=1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = f_ymulti;
denomY = t_ymulti;
// ymagratio=(int)(f_ymulti/t_ymulti);
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = 1;
denomY = t_ymulti;
}
for(int iterx=0;iterx<t_xresosize;iterx+=t_xstep)
{
for(int itery=0;itery<t_yresosize;itery+=t_ystep)
{
int toIndex = cellmap_slow(t_pre,t_suf,iterx,itery);
//get the closest point to the from layer in the to neuron layer.
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), f_pre, f_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-conn.length/2*f_xstep;itxx<newx+((conn.length%2)==0?conn.length:conn.length+1)/2*f_xstep;itxx+=f_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-conn[0].length/2*f_ystep;ityy<newy+((conn[0].length%2)==0?conn[0].length:conn[0].length+1)/2*f_ystep;ityy+=f_ystep)
{
xborder = itxx % f_xresosize;
yborder = ityy % f_yresosize;
if(xborder<0) xborder+=f_xresosize;
if(yborder<0) yborder+=f_yresosize;
int neuronID;
neuronID=cellmap_slow(f_pre,f_suf,xborder,yborder);
if( neuronID <= neuron_end && neuronID >= base )
{
if(Math.abs(conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep])!=0)
{
synapses=getSynapses(neuronID,delay,toIndex); //read the old synapses
double synWei = stre*conn[(itxx-newx+conn.length/2*f_xstep)/f_xstep][(ityy-newy+conn[0].length/2*f_ystep)/f_ystep];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
syn= new Synapse(toIndex,synWei,type);
synapses.add(syn);
}
}
}
}
}
}
}
else //divergent
{
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=0;iterx<f_xresosize;iterx+=f_xstep)
{
for(int itery=0;itery<f_yresosize;itery+=f_ystep)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
if( neuronID <= neuron_end && neuronID >= base )
{
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), t_pre, t_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-conn.length/2*t_xstep;itxx<newx+((conn.length%2)==0?conn.length:conn.length+1)/2*t_xstep;itxx+=t_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-conn[0].length/2*t_ystep;ityy<newy+((conn[0].length%2)==0?conn[0].length:conn[0].length+1)/2*t_ystep;ityy+=t_ystep)
{
xborder = itxx % t_xresosize;
yborder = ityy % t_yresosize;
if(xborder<0) xborder+=t_xresosize;
if(yborder<0) yborder+=t_yresosize;
int toIndex = cellmap_slow(t_pre,t_suf,xborder,yborder);
synapses=getSynapses(neuronID,delay,toIndex); //read the old synapses;
if(Math.abs(conn[(itxx-newx+conn.length/2*t_xstep)/t_xstep][(ityy-newy+conn[0].length/2*t_ystep)/t_ystep])!=0)
{
double synWei = stre*conn[(itxx-newx+conn.length/2*t_xstep)/t_xstep][(ityy-newy+conn[0].length/2*t_ystep)/t_ystep];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
syn=new Synapse(toIndex,synWei,type);
synapses.add(syn);
}
}
}
}
}
}
}
}
return maxOutput;
}
*/
@Deprecated
public double connect(String f_pre, String f_suf, String t_pre, String t_suf, boolean convergent, double stre, int type, double delay, double[][] trans)
////////////////////////////////////////////////////////////////////////
{
double maxOutput = -1.0;
double [][] conn;
// System.out.println("connect");
int f_xmulti,f_ymulti,t_xmulti,t_ymulti;
f_xmulti=getXmultiplier(f_pre,f_suf);
f_ymulti=getYmultiplier(f_pre,f_suf);
t_xmulti=getXmultiplier(t_pre,t_suf);
t_ymulti=getYmultiplier(t_pre,t_suf);
int f_xstep,f_ystep,f_xresosize,f_yresosize;
int t_xstep,t_ystep,t_xresosize,t_yresosize;
int denomX=0,numX=0;
int denomY=0,numY=0;
int xmagratio=0;
int ymagratio=0;
int xborder,yborder;
int newx=0;
int newy=0;
String fromNeur,toNeur;
Synapse syn;
TreeSet<Synapse> synapses;
int[] xy=new int[2];
if(type==1&&stre>0) // these maynot be useful for new neuronal model
System.err.println("sign of connection is wrong");
if(type==0&&stre<0)
System.err.println("sign of connection is wrong");
if(stre!=0)
{
if(f_xmulti>0)
{
f_xstep=1;
f_xresosize=f_xmulti*edgeLengthX;
}
else
{
f_xstep=-f_xmulti;
f_xresosize=edgeLengthX;
}
if(f_ymulti>0)
{
f_ystep=1;
f_yresosize=f_ymulti*edgeLengthY;
}
else
{
f_ystep=-f_ymulti;
f_yresosize=edgeLengthY;
}
if(t_xmulti>0)
{
t_xstep=1;
t_xresosize=t_xmulti*edgeLengthX;
}
else
{
t_xstep=-t_xmulti;
t_xresosize=edgeLengthX;
}
if(t_ymulti>0)
{
t_ystep=1;
t_yresosize=t_ymulti*edgeLengthY;
}
else
{
t_ystep=-t_ymulti;
t_yresosize=edgeLengthY;
}
// System.gc();
if(convergent) //convergence connections from many to 1, first iterate to side
{
conn = FunUtil.lRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=0;iterx<f_xresosize;iterx+=f_xstep)
{
for(int itery=0;itery<f_yresosize;itery+=f_ystep)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
// if( neuronID <= neuron_end && neuronID >= base )
{
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), t_pre, t_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-((int)((double)(conn.length/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep)))+1)*(t_xstep);itxx<=newx+((int)((double)(((conn.length%2)==0?conn.length-1:conn.length)/2)*(((double)numX/(double)denomX*(double)f_xstep/(double)t_xstep))))*(t_xstep);itxx+=t_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-((int)((double)(conn[0].length/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep)))+1)*(t_ystep);ityy<=newy+((int)((double)(((conn[0].length%2)==0?conn[0].length-1:conn[0].length)/2)*(((double)numY*(double)f_ystep/(double)denomY/(double)t_ystep))))*(t_ystep);ityy+=t_ystep)
{
xborder = itxx % t_xresosize;
yborder = ityy % t_yresosize;
if(xborder<0) xborder+=t_xresosize;
if(yborder<0) yborder+=t_yresosize;
int toIndex = cellmap_slow(t_pre,t_suf,xborder,yborder);
synapses=getSynapses(neuronID,delay,toIndex); //read the old synapses;
int maX = (int)((((double)itxx)/(double)numX*(double)denomX)-iterx)/f_xstep+conn.length/2;
int maY = (int)((((double)ityy)/(double)numY*(double)denomY)-itery)/f_ystep+conn[0].length/2;
if(maX>=0 && maX < conn.length && maY>=0 && maY < conn[0].length )
{
if(Math.abs(conn[maX][maY])!=0)
{
double synWei = stre*conn[maX][maY];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
syn = modelFactory.createSynapse (
toIndex,
( byte ) type,
( float ) synWei );
synapses.add(syn);
}
}
}
}
}
}
}
}
else //divergent
{
conn = FunUtil.rRotate90(trans);
if(t_xmulti<0&&f_xmulti>0)
{
numX = 1;
denomX = f_xmulti;
}
else if(t_xmulti<0&&f_xmulti<0)
{
numX = 1;
denomX = 1;
}
else if(t_xmulti>0&&f_xmulti>0)
{
numX = t_xmulti;
denomX = f_xmulti;
}
else if(t_xmulti>0&&f_xmulti<0)
{
numX = t_xmulti;
denomX = 1;
}
if(t_ymulti<0&&f_ymulti>0)
{
numY = 1;
denomY = f_ymulti;
}
else if(t_ymulti<0&&f_ymulti<0)
{
numY = 1;
denomY = 1;
}
else if(t_ymulti>0&&f_ymulti>0)
{
numY = t_ymulti;
denomY = f_ymulti;
}
else if(t_ymulti>0&&f_ymulti<0)
{
numY = t_ymulti;
denomY = 1;
}
for(int iterx=0;iterx<f_xresosize;iterx+=f_xstep)
{
for(int itery=0;itery<f_yresosize;itery+=f_ystep)
{
int neuronID=cellmap_slow(f_pre,f_suf,iterx,itery);
// if( neuronID <= neuron_end && neuronID >= base )
// {
xy=closePoint((int)((double)numX/(double)denomX*iterx),(int)((double)numY/(double)denomY*itery), t_pre, t_suf);
newx=xy[0];
newy=xy[1];
for(int itxx=newx-conn.length/2*t_xstep;itxx<newx+((conn.length%2)==0?conn.length:conn.length+1)/2*t_xstep;itxx+=t_xstep) // if matrix is even, the center is center+0.5, if matrix is odd, center is center
{
for(int ityy=newy-conn[0].length/2*t_ystep;ityy<newy+((conn[0].length%2)==0?conn[0].length:conn[0].length+1)/2*t_ystep;ityy+=t_ystep)
{
xborder = itxx % t_xresosize;
yborder = ityy % t_yresosize;
if(xborder<0) xborder+=t_xresosize;
if(yborder<0) yborder+=t_yresosize;
int toIndex = cellmap_slow(t_pre,t_suf,xborder,yborder);
synapses=getSynapses(neuronID,delay,toIndex); //read the old synapses;
if(Math.abs(conn[(itxx-newx+conn.length/2*t_xstep)/t_xstep][(ityy-newy+conn[0].length/2*t_ystep)/t_ystep])!=0)
{
double synWei = stre*conn[(itxx-newx+conn.length/2*t_xstep)/t_xstep][(ityy-newy+conn[0].length/2*t_ystep)/t_ystep];
if(Math.abs(synWei) > SIFNeuron.maxWeight)
{
if( Math.abs(synWei) / SIFNeuron.maxWeight > maxOutput) maxOutput = Math.abs(synWei) / SIFNeuron.maxWeight;
}
syn = modelFactory.createSynapse (
toIndex,
( byte ) type,
( float ) synWei );
synapses.add(syn);
}
}
}
// }
}
}
}
}
return maxOutput;
}
/* private TreeSet<Synapse> getSynapses(String from, double delay, String to)
{
if(!branchmaps[( cellmap.get(from)).intValue()- base].containsKey(delay+" "+node))
branchmaps[( cellmap.get(from)).intValue()-base].put(delay+" "+node,new TreeSet<Synapse>());
return branchmaps[(cellmap.get(from)).intValue()-base].get(delay+" "+node);
//return branchmaps[( cellmap.get(from)).intValue()].get(delay+" "+node);
}
*/
private TreeSet<Synapse> getSynapses(int from, double delay, int to)
////////////////////////////////////////////////////////////////////////
{
int node=FunUtil.hostId(nodeEndIndices,to);
if(!branchmaps[from- base].containsKey(delay+" "+node))
branchmaps[from-base].put(delay+" "+node,new TreeSet<Synapse>());
return branchmaps[from-base].get(delay+" "+node);
//return branchmaps[( cellmap.get(from)).intValue()].get(delay+" "+node);
}
/*
public void populateNeurons()
////////////////////////////////////////////////////////////////////////
{
neurons= new Neuron[numberOfNeurons];
int xTotal=0;
int yTotal=0;
int xstep=0;
int ystep=0;
int xMul,yMul;
String neu;
for(int iter=0;iter<layer_structure.size();iter++)
{
xMul = layer_structure.get(iter).getXmultiplier();
yMul = layer_structure.get(iter).getYmultiplier();
if(xMul < 0 )
{
xTotal=xedgeLength;
xstep=-xMul;
}
else
{
xTotal=xedgeLength*xMul;
xstep=1;
}
if(yMul < 0 )
{
yTotal=yedgeLength;
ystep=-yMul;
}
else
{
yTotal=yedgeLength*yMul;
ystep=1;
}
for(int x = 0 ; x < xTotal; x+=xstep)
{
for(int y = 0 ; y < yTotal; y+=ystep)
{
neu=layer_structure.get(iter).getPrefix()+","+x+","+y+","+layer_structure.get(iter).getSuffix();
// System.out.println(neu+cellmap.get(neu));
neurons[cellmap.get(neu)] = new SIFNeuron(-0.07,new Axon(null));
}
}
}
}
public void populateNeurons(int hostID)
////////////////////////////////////////////////////////////////////////
{
neurons= new Neuron[numberOfNeurons];
int xTotal=0;
int yTotal=0;
int xstep=0;
int ystep=0;
int xMul,yMul;
String neu;
for(int iter=0;iter<layer_structure.size();iter++)
{
xMul = layer_structure.get(iter).getXmultiplier();
yMul = layer_structure.get(iter).getYmultiplier();
if(xMul < 0 )
{
xTotal=xedgeLength;
xstep=-xMul;
}
else
{
xTotal=xedgeLength*xMul;
xstep=1;
}
if(yMul < 0 )
{
yTotal=yedgeLength;
ystep=-yMul;
}
else
{
yTotal=yedgeLength*yMul;
ystep=1;
}
for(int x = 0 ; x < xTotal; x+=xstep)
{
for(int y = 0 ; y < yTotal; y+=ystep)
{
neu=layer_structure.get(iter).getPrefix()+","+x+","+y+","+layer_structure.get(iter).getSuffix();
// System.out.println(neu+cellmap.get(neu));
neurons[cellmap.get(neu)] = new SIFNeuron(-0.07,new Axon(null));
}
}
}
}
*/
/***********************************************************************
* Given tolayer of neuron and iterx, itery coordinates,
* return the closest point.
*
* Called from popScaffold().
*
* @param iterx
* @param itery
* @param tpre
* @param tsuf
* @return
***********************************************************************/
public int [ ] closePoint (
final int iterx,
final int itery,
final String tpre,
final String tsuf )
////////////////////////////////////////////////////////////////////////
{
final int
txmulti = getXmultiplier ( tpre, tsuf ),
tymulti = getYmultiplier ( tpre, tsuf );
// fxmulti=getXmultiplier(fpre,fsuf);
// fymulti=getYmultiplier(fpre,fsuf);
String thisSpot;
int txstep,tystep;
int
fxmult,
fymult,
txmult,
tymult;
if ( txmulti > 0 )
{
txmult = txmulti;
}
else
{
txmult = 1;
}
if ( tymulti > 0 )
{
tymult = tymulti;
}
else
{
tymult = 1;
}
/*
if(fxmulti>0)
{
fxmult=fxmulti;
}
else
{
fxmult=1;
}
if(fymulti>0)
{
fymult=fymulti;
}
else
{
fymult=1;
}
*/
int
newx = iterx,
newy = itery;
thisSpot = tpre + "," + newx + "," + newy + "," + tsuf;
if ( cellmap_slow ( tpre, tsuf, newx, newy ) == -1 )
{
// the neuron is not in the grid
if ( txmulti > 0 )
{
txstep = 1;
}
else
{
txstep = -txmulti;
}
if ( tymulti > 0 )
{
tystep = 1;
}
else
{
tystep = -tymulti;
}
final int
modx = iterx % txstep,
mody = itery % tystep;
// System.out.println("x"+iterx+" y"+itery+" modx"
// +modx+" mody"+mody+" stepx"+txstep+" stepy"+tystep);
if ( txstep > 2 * modx )
{
newx = iterx - modx;
}
else
{
newx = iterx + ( txstep ) - modx;
}
if ( tystep > 2 * mody )
{
newy = itery - mody;
}
else
{
newy = itery + ( tystep ) - mody;
}
/*
newx = newx % (txmult*xedgeLength);
newy = newy % (tymult*yedgeLength);
if(newx<0) newx+=(txmult*xedgeLength);
if(newy<0) newy+=(tymult*yedgeLength);
*/
/*
if(newx>txmult*xedgeLength-1)
{
newx-=txmult*xedgeLength;
}
if(newx<0)
{
newx+=txmult*xedgeLength;
}
if(newy>tymult*yedgeLength-1)
{
newy-=tymult*yedgeLength;
}
if(newy<0)
{
newy+=tymult*yedgeLength;
}
*/
}
final int [ ] answer = new int [ ] { newx, newy };
// thisSpot=tpre + ","+newx + "," + newy + ","+tsuf;
// if(cellmap.containsKey(thisSpot))
// {
return answer;
// }
// else
// {
// answer[0]=-1;
// answer[1]=-1;
// return answer;
// throw new RuntimeException("the layers length is not well defined");
// }
}
/**
* For debugging, pring out the connections connects from neuron with String id .
* The format is Prefix,x,y,Suffix
*
* @param Neuron string
* @param print stream p
* @return Information.
***********************************************************************/
public String connectFrom(String id, PrintStream p)
////////////////////////////////////////////////////////////////////////
{
p.println("finding connections from"+id);
String [] items = id.split(",");
int index = cellmap_slow(items[0],items[3],Integer.parseInt(items[1]),Integer.parseInt(items[2])) ;
Iterator entryIter = axons.entrySet().iterator();
while(entryIter.hasNext())
{
Map.Entry<Integer, Axon> entry = (Map.Entry<Integer, Axon>)entryIter.next();
Integer sourceId = entry.getKey();
Axon axon = entry.getValue();
for(int i =0; i< axon.branches.length; i++)
{
for(int j=0;j<axon.branches[i].synapses.length;j++)
{
if ( axon.branches[i].synapses[j].getTargetNeuronIndex ( ) == index )
{
p.println (
id + " has " + axon.branches[i].synapses[j].getType ( )
+ " with strength "
+ axon.branches[i].synapses[j].getWeight ( )
+ " synapse From: "
+ sourceId
+ " celltype "
+ celltype_slow(sourceId)
+" base:"
+base);
}
}
}
}
p.println("End");
/*
int iter;
int iter1;
int iter2;
String [] items = id.split(",");
int index = cellmap_slow(items[0],items[3],Integer.parseInt(items[1]),Integer.parseInt(items[2])) ;
if(index!=-1)
{
p.println("id"+index);
String synType="";
for(iter=0;iter<numberOfNeurons;iter++)
{
for(iter1=0;iter1<neurons[iter].getAxon().branches.length;iter1++)
{
for(iter2=0;iter2<neurons[iter].getAxon().branches[iter1].synapses.length;iter2++)
{
if(neurons[iter].getAxon().branches[iter1].synapses[iter2].to==index)
{
if(neurons[iter].getAxon().branches[iter1].synapses[iter2].type==0)
synType="Glutamate";
if(neurons[iter].getAxon().branches[iter1].synapses[iter2].type==1)
synType="GABA";
p.println(id + " has " + synType + " with strength " + neurons[iter].getAxon().branches[iter1].synapses[iter2].weight + " synapse From: " + (celltype_slow(iter)));
}
}
}
}
p.println("End");
}
else
{
return "none";
}
*/
return "yes";
}
/*
public String connectFrom(String id)
////////////////////////////////////////////////////////////////////////
{
int iter;
int iter1;
int iter2;
int index;
if(cellmap.containsKey(id))
{ index=cellmap.get(id);
String synType="";
for(iter=0;iter<numberOfNeurons;iter++)
{
for(iter1=0;iter1<neurons[iter].getAxon().branches.length;iter1++)
{
for(iter2=0;iter2<neurons[iter].getAxon().branches[iter1].synapses.length;iter2++)
{
if(neurons[iter].getAxon().branches[iter1].synapses[iter2].to==index)
{
if(neurons[iter].getAxon().branches[iter1].synapses[iter2].type==0)
synType="Glutamate";
if(neurons[iter].getAxon().branches[iter1].synapses[iter2].type==1)
synType="GABA";
System.out.println(id + " has " + synType + " with strength " + neurons[iter].getAxon().branches[iter1].synapses[iter2].weight + " synapse From: " + (celltype[iter]));
}
}
}
}
}
else
{
return "none";
}
return "yes";
}
*/
/*
public String connectTo(String id)
////////////////////////////////////////////////////////////////////////
{
int iter;
int iter1;
int iter2;
int index;
if(cellmap.containsKey(id))
{
index=cellmap.get(id);
String synType="";
System.out.println( id + " connects to");
for(iter1=0;iter1<neurons[index].getAxon().branches.length;iter1++)
{
for(iter2=0;iter2<neurons[index].getAxon().branches[iter1].synapses.length;iter2++)
{
if(neurons[index].getAxon().branches[iter1].synapses[iter2].type==0)
synType="Glutamate";
if(neurons[index].getAxon().branches[iter1].synapses[iter2].type==1)
synType="GABA";
System.out.println(" "+(celltype[neurons[index].getAxon().branches[iter1].synapses[iter2].to])+ "--------"+ synType + " with strength " + neurons[index].getAxon().branches[iter1].synapses[iter2].weight);
}
}
}
else
{
return "none";
}
return "yes";
}
*/
/*
public int[] getLayerIndices(String prefix, String suffix)
////////////////////////////////////////////////////////////////////////
{
int xstep,ystep,xresosize,yresosize;
if(getXmultiplier(prefix,suffix)>=1.0)
{
xstep=1;
xresosize=(int) getXmultiplier(prefix,suffix)*xedgeLength;
}
else
{
xstep=(int)(1.0/getXmultiplier(prefix,suffix));
xresosize=xedgeLength;
}
if(getYmultiplier(prefix,suffix)>=1.0)
{
ystep=1;
yresosize=(int) getYmultiplier(prefix,suffix)*yedgeLength;
}
else
{
ystep=(int)(1.0/getYmultiplier(prefix,suffix));
yresosize=yedgeLength;
}
int[] indices=new int[layerNumNeurons(prefix,suffix)];
int curr=0;
for(int a=0;a<xresosize;a+=xstep)
{
for(int b=0;b<yresosize;b+=ystep)
{
indices[curr]=( cellmap.get(prefix + ","+a + "," + b + ","+suffix)).intValue();
curr++;
}
}
return indices;
}
public int[] namesToIndices(String[] names)
////////////////////////////////////////////////////////////////////////
{
int[] indices=new int[names.length];
for(int a=0;a<names.length;a++)
{
indices[a]=( cellmap.get(names[a])).intValue();
}
return indices;
}
*/
public void killMaps()
////////////////////////////////////////////////////////////////////////
{
// cellmap=null;
// celltype=null;
// branchmaps=null;
}
public int getXEdgeLength()
////////////////////////////////////////////////////////////////////////
{
return edgeLengthX;
}
public int getYEdgeLength()
////////////////////////////////////////////////////////////////////////
{
return edgeLengthY;
}
/***********************************************************************
* Set up the target host (binary long type) information through network (JPVM).
* @param info
* @param pas
*
* @throws jpvmException
***********************************************************************/
public void parseTarget(JpvmInfo info, SimulatorParser pas) throws jpvmException
////////////////////////////////////////////////////////////////////////
{
TargetID [] targetID = new TargetID[info.numTasks];
for(int i = 0 ; i < info.numTasks; i++)
{
if(i != info.idIndex)
{
targetID[i] = new TargetID(info.idIndex);
}
}
Iterator<Integer> keyIter = pas.layerStructure.axons.keySet().iterator();
long self = (1L<<info.idIndex);
while(keyIter.hasNext())
{
int target = keyIter.next();
int hostDD = FunUtil.hostId(pas.layerStructure.nodeEndIndices,target);
if(hostDD != info.idIndex)
{
targetID[hostDD].target.add(target);
}
else if(hostDD == info.idIndex)
{
if((pas.layerStructure.neurons[target - pas.layerStructure.base].getTHost() & self )==0) // if the neuron doen'st have a target synapse at node then set it.
{
pas.layerStructure.neurons[target - pas.layerStructure.base].setTHost((pas.layerStructure.neurons[target - pas.layerStructure.base].getTHost() | self));
}
}
}
for(int i = 0 ; i < info.numTasks; i++)
{
if(i != info.idIndex)
{
jpvmBuffer buf2 = new jpvmBuffer();
buf2.pack(targetID[i]); //pack the info
info.jpvm.pvm_send(buf2, info.tids[i] ,NetMessageTag.assignTargets);
}
}
//receive all the target info
jpvmMessage m;
for(int i = 0 ; i < info.numTasks-1; i++)
{
m = info.jpvm.pvm_recv(NetMessageTag.assignTargets); //receive info from others
TargetID reTID = (TargetID)m.buffer.upkcnsobj();
long setID = (1L<<(reTID.target.get(0)));
int neuronID;
for(int ii=1; ii< reTID.target.size(); ii++)
{
neuronID = reTID.target.get(ii);
if((pas.layerStructure.neurons[neuronID - pas.layerStructure.base].getTHost() & setID )==0) // if the neuron doen'st have a target synapse at node then set it.
{
pas.layerStructure.neurons[neuronID - pas.layerStructure.base].setTHost((pas.layerStructure.neurons[neuronID - pas.layerStructure.base].getTHost() | (setID)));
}
}
}
}
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
}