forums.silverfrost.com

[DanRRight]

How to see values of derived type variables in SDBG?

[PaulLaidler]

Double click on SPECIES in the Variables window.
Then double click on SPECIES(0):TYPE(CELL) in the SPECIES window.
Then double click on var: REAL*4 POINTER ::(1) in the SEPCIES(0) window.

[DanRRight]

Thanks, i was initially confused with "Syntax error" messages and absence of bubble help (like with usual arrays) doing that and thought this option does not work at all

[DanRRight]

10 years ago i tried to use derived types with 32bit FTN95 and failed. Crashes, access violations, irrational behavior....Now i need to allocate variable number of entries in the array (imagine some allocatable 2D array with variable number of elements of each row, every call different) and for that allocation of standard arrays does not work (Standard does not allows that by some reason, that does not work with other compilers too) and hence i need to use derived types again. Why derived types allow that functionality is beyond me.

And i am failing again by multiple reasons. Here is first one. Is anything wrong with this text? It is the same one as above which works, but this time the allocation takes place inside the function in the module not in the main program. It wrongfully tells that array is allocated and then it tries to deallocate it and fails. I compile FTN95 aaa.f95 /link /debug /undef /64 >zzz

[PaulLaidler]

species(0)%v is allocated just one element species(0)%v(1) so when it comes to the print, species(0)%var(2) is out of range.

species(0:3) should be initialised before testing for ALLOCATED. For example FTN95 allows...

do i = 0,3
nullify(species(i)%var)
end do

but off hand I don't know the "right" way to do this.

[DanRRight]

Looks like nullify could be that missing piece in the puzzle...Thanks Paul

[mecej4]

Dan, your program is almost working. All that you have to do is to make sure that subscript bounds are honored, or, equivalently, allocate arrays with sufficient size.

Here is a fixed-up version:

[JohnCampbell]

I suggest that an enhanced version of the derived type might be more functional, as in the example below

[DanRRight]

Let me ask all of you what compiler version do you use because not a single variant mentioned above works with latest version and switches /check or /undef. Some work with latest 9.02 if use nullify. But if i add nullify the variant conflicts with gfortran complaining that this is not a pointer. Without /debug and check the ones above work but what the point to use compiler without major checks ?

Another point is that unfortunately these 2D variants were not the ones which are needed to me. They were oversimplified and what actually needed is 3D or 4D or even more dimensional variants so the derived types will have 3-4 variables with 3-4 dimensions look like this

var1(idim1)%var2(idim2)%var3(idim3,idim4)

And here i fail completely...Both on FTN95 and Gfortran. Even without /debug /check

Hence because the problem could not be compiler-related i have to explain in detail where and how exactly i plan to use derived types. May be i am doing everything wrong from the start.

This is to model relativistic plasma but i will better explain that on similar example from real life. Suppose we investigate 4 species of fish. We divided aquarium on 100 levels of depth installed sensors in each level. On each fish we placed chip which controls them on 12 parameters. And we know exactly how many fish of each species is in each level of aquarium. So

dimension idim1 - idim1 = 4 species of fish
dimension idim2 - Aquarium divided on idim2 levels of depth
dimension idim3 - each fish is tracked by idim3=12 parameters (their temperature, oxygen content in blood, CO2 content etc)
dimension idim4 - tells how many fish of each species is currently in each level of aquarium

When allocating arrays we need to deallocate all the data for each fish, allocate array again based on recent data obtained from the sensors and load this new data. Below we deallocate first, then allocate the data and test if we see on the water surface at least one fish (print)

[mecej4]

Dan, I used 9.02 without /check or /undef.

FTN95 gives, if I am not mistaken, an incorrect warning:

[JohnCampbell]

To previously test the program, I used PLATO (which was set to Gfortran !)

Now with /64 it crashes, but works with 32-bit

[DanRRight]

So do you find any problems in my setup of a bit more complex 4D derived type in previous post? It does not work at all

The reason why I use derived type is that it is impossible to allocate just one dimension of standard array of arbitrary size independent of other dimensions. Before i collected all data in the standard classical array like this

array (idim3,idim4,idim2,idim1)

where as i noted above idim1 was for 4 our different types of "fish" - gold fish, shark, whale and say crab (where last two are not exactly a "fish"). If number of fish of different types is very different (say, we track just one single piece of whale which is rare in the nature) then storing this way becomes inefficient because we allocate for whale same amount of storage as for other fish. Even more inefficient becomes storage when you realize that fish may gather just in some preferable layers of aquarium. If crab gather only on the bottom of it - we need to allocate huge number for idim4 (maximum allowed number of fish for specific layer) and keep that for all other layers and all kinds of fish because allocation of different idim4 for different layers (idim2) and different kinds of fish (idim1) is not allowed - all have to have the same idim4.

As a result if you control 1 billion of fish (particles - electrons, photons, ions and all sorts of compounds) with 12 parameters 4 bytes each you formally need not more than only 12e9*4 = 48 GB of RAM while with array like above you'll need sometimes a Terabyte size of mostly empty sparce array !!!

[JohnCampbell]

[JohnCampbell]

Dan,

I have not used multi-level derrived types with allocatable components before.
It certainly gives versatility of the data structure.

The de-allocate code in the example above is very under-done !
If you have allocatable components that need to be de-allocated then all their allocatable components must also be specifically deallocated first.

I left off the test
if ( allocated ( var1(idim1)%var2 ) ) ...
The required code would have to deallocate any %var3 allocated to %var2

[JohnCampbell]

I have expanded to a smaller example to show deallocate of allocatable components, which appears to work.